@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1256

package/esm2022/lib/controls/date-input/date-input-selection-strategies/date-input-selection-strategy-base.mjs

@@ -0,0 +1,57 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+/**
+ * Contains the logic for selecting, formatting, and parsing date dates for a specific selection mode.
+ */
+export class DateInputSelectionStrategyBase {
+    /** Parses the string into a date using the provided parse formats. */
+    parseString(value, parseFormats, opts) {
+        if (!value) {
+            return null;
+        }
+        const date = moment(value, parseFormats);
+        if (date.isValid()) {
+            // If we're in a temporary state (when the user is typing in a textbox), we need to set the year to the current year if it's before the min year
+            // This prevents the calendars from showing unhelpful dates that are in the distant past before the user finishes typing in the date.
+            // We don't do this modification when the real selection happens on textbox blur.
+            if (opts?.shiftToCurrentYearIfBelow && date.isBefore(opts.shiftToCurrentYearIfBelow)) {
+                date.set('year', moment().year());
+            }
+            return date.toDate();
+        }
+        return null;
+    }
+    /** Returns a new selection for the provided date. */
+    getSelectionForQuickSelectDate(date, existingSelection) {
+        return this.getSelectionFromDate(date, existingSelection);
+    }
+    /** Returns the view for the primary calendar for the selection and selection mode */
+    getPrimaryCalendarView(selection, minDate, maxDate, currentView) {
+        let date;
+        // If we have a range, use the end date, defaulting to the start date or today
+        if (DateInput.isSelectionRange(selection)) {
+            date = selection.end || selection.start || new Date();
+            // If we have a single date, use it, defaulting to today
+        }
+        else {
+            date = selection || new Date();
+        }
+        // Ensure the date is within the min and max dates
+        date = date < minDate ? minDate : date;
+        date = date > maxDate ? maxDate : date;
+        // If the current calendar view mode is valid for the selection mode, use it, otherwise use the selection view mode
+        // This prevents the calendar from changing view modes as the user types/blurs the textboxes as long as the view mode is valid
+        const viewMode = this.validViewModes.includes(currentView.mode) ? currentView.mode : this.selectionViewMode;
+        return { mode: viewMode, date };
+    }
+    ;
+    /**
+     * Returns the view for the secondary calendar for the selection and selection mode.
+     * This is is only used by the range selection strategy. All others just return the current date.
+     */
+    getSecondaryCalendarView(selection, minDate, maxDate, currentView) {
+        return { mode: this.selectionViewMode, date: new Date() };
+    }
+    ;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-input-selection-strategy-base.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/controls/date-input/date-input-selection-strategies/date-input-selection-strategy-base.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD;;GAEG;AACH,MAAM,OAAgB,8BAA8B;IASlD,sEAAsE;IACtE,WAAW,CAAC,KAAgC,EAAE,YAAsB,EAAE,IAA+B;QACnG,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QAEzC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YACnB,gJAAgJ;YAChJ,qIAAqI;YACrI,iFAAiF;YACjF,IAAI,IAAI,EAAE,yBAAyB,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,yBAAyB,CAAC,EAAE,CAAC;gBACrF,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;YACpC,CAAC;YAED,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;QACvB,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAaD,qDAAqD;IACrD,8BAA8B,CAAC,IAAU,EAAE,iBAA8C;QACvF,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC;IAC5D,CAAC;IAMD,qFAAqF;IACrF,sBAAsB,CAAC,SAAqC,EAAE,OAAa,EAAE,OAAa,EAAE,WAA0B;QACpH,IAAI,IAAU,CAAC;QAEf,8EAA8E;QAC9E,IAAI,SAAS,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1C,IAAI,GAAG,SAAS,CAAC,GAAG,IAAI,SAAS,CAAC,KAAK,IAAI,IAAI,IAAI,EAAE,CAAC;YACxD,wDAAwD;QACxD,CAAC;aAAM,CAAC;YACN,IAAI,GAAG,SAAS,IAAI,IAAI,IAAI,EAAE,CAAC;QACjC,CAAC;QAED,kDAAkD;QAClD,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QACvC,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QAEvC,mHAAmH;QACnH,8HAA8H;QAC9H,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC;QAE5G,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAClC,CAAC;IAAA,CAAC;IAEF;;;OAGG;IACH,wBAAwB,CAAC,SAAqC,EAAE,OAAa,EAAE,OAAa,EAAE,WAA0B;QACtH,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,iBAAiB,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,EAAE,CAAA;IAC3D,CAAC;IAAA,CAAC;CACH","sourcesContent":["import moment from \"moment\";\r\nimport { Calendar } from \"../../calendar/calendar.types\";\r\nimport { DateInput } from \"../date-input.types\";\r\n\r\n/**\r\n * Contains the logic for selecting, formatting, and parsing date dates for a specific selection mode.\r\n */\r\nexport abstract class DateInputSelectionStrategyBase {\r\n  /** The calendar view mode where selections occur for this mode. This is used to zoom the calendar into the selection */\r\n  abstract readonly selectionViewMode: Calendar.ViewMode;\r\n  /** The list of view modes that are accessible by this selection mode. Used to determine whether the calendar view needs to be changed or not on selection change. */\r\n  abstract readonly validViewModes: Calendar.ViewMode[];\r\n  /** Whether the secondary textbox should be shown for this selection mode */\r\n  abstract readonly showSecondaryTextbox: boolean;\r\n  /** Whether the secondary calendar should be shown for this selection mode */\r\n  abstract readonly showSecondaryCalendar: boolean;\r\n  /** Parses the string into a date using the provided parse formats. */\r\n  parseString(value: string | null | undefined, parseFormats: string[], opts?: DateInput.ParsingOptions): Date | null {\r\n    if (!value) {\r\n      return null;\r\n    }\r\n    const date = moment(value, parseFormats);\r\n\r\n    if (date.isValid()) {\r\n      // If we're in a temporary state (when the user is typing in a textbox), we need to set the year to the current year if it's before the min year\r\n      // This prevents the calendars from showing unhelpful dates that are in the distant past before the user finishes typing in the date.\r\n      // We don't do this modification when the real selection happens on textbox blur.\r\n      if (opts?.shiftToCurrentYearIfBelow && date.isBefore(opts.shiftToCurrentYearIfBelow)) {\r\n        date.set('year', moment().year());\r\n      }\r\n\r\n      return date.toDate();\r\n    }\r\n\r\n    return null;\r\n  }\r\n  /** Formats a date input selection into values to be displayed in the date input's textboxes. */\r\n  abstract formatSelection(selection?: DateInput.Selection | null): DateInput.TextboxGroup['value'];\r\n  /** \r\n   * Parses the date input's values into a date selection to display in the calendars.\r\n   * `parseFromEnd` controls whether the fixed range modes (last7days, last28days) will key off the end date instead of the start date.\r\n   * This is used when the user is typing in the end date textbox.\r\n   */\r\n  abstract parseTextboxValues(value: DateInput.TextboxGroup['value'], parseFormats: string[], opts?: DateInput.ParsingOptions): DateInput.Selection | null;\r\n  /** Returns a selection given a date and an existing selection (in the case of date ranges). Called when a date is clicked in the calendars. */\r\n  abstract getSelectionFromDate(date: Date, existingSelection?: DateInput.Selection | null): DateInput.Selection | null;\r\n  /** Returns a new selection that best matches the given previous selection from a different selection mode */\r\n  abstract getNewSelectionFromExisting(previousSelection?: DateInput.Selection | null): DateInput.Selection | null;\r\n  /** Returns a new selection for the provided date. */\r\n  getSelectionForQuickSelectDate(date: Date, existingSelection?: DateInput.Selection | null): DateInput.Selection | null {\r\n    return this.getSelectionFromDate(date, existingSelection);\r\n  }\r\n  /** Returns the next selection. Called by the date input steppers to move the range. */\r\n  abstract getNextSelection(selection: DateInput.Selection | null): DateInput.Selection | null;\r\n  /** Returns the previous selection. Called by the date input steppers to move the range. */\r\n  abstract getPreviousSelection(selection: DateInput.Selection | null): DateInput.Selection | null;\r\n  \r\n  /** Returns the view for the primary calendar for the selection and selection mode */\r\n  getPrimaryCalendarView(selection: DateInput.Selection | null, minDate: Date, maxDate: Date, currentView: Calendar.View): Calendar.View {\r\n    let date: Date;\r\n\r\n    // If we have a range, use the end date, defaulting to the start date or today\r\n    if (DateInput.isSelectionRange(selection)) {\r\n      date = selection.end || selection.start || new Date();\r\n    // If we have a single date, use it, defaulting to today\r\n    } else {\r\n      date = selection || new Date();\r\n    }\r\n\r\n    // Ensure the date is within the min and max dates\r\n    date = date < minDate ? minDate : date;\r\n    date = date > maxDate ? maxDate : date;\r\n\r\n    // If the current calendar view mode is valid for the selection mode, use it, otherwise use the selection view mode\r\n    // This prevents the calendar from changing view modes as the user types/blurs the textboxes as long as the view mode is valid\r\n    const viewMode = this.validViewModes.includes(currentView.mode) ? currentView.mode : this.selectionViewMode;\r\n\r\n    return { mode: viewMode, date };\r\n  };\r\n  \r\n  /**\r\n   * Returns the view for the secondary calendar for the selection and selection mode.\r\n   * This is is only used by the range selection strategy. All others just return the current date.\r\n   */\r\n  getSecondaryCalendarView(selection: DateInput.Selection | null, minDate: Date, maxDate: Date, currentView: Calendar.View): Calendar.View {\r\n    return { mode: this.selectionViewMode, date: new Date() }\r\n  };\r\n}\r\n"]}

package/esm2022/lib/controls/date-input/date-input-selection-strategies/day-selection-strategy.mjs

@@ -0,0 +1,62 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+import { DateInputSelectionStrategyBase } from "./date-input-selection-strategy-base";
+/**
+ * Selection strategy for the 'day' selection mode.
+ */
+export class DaySelectionStrategy extends DateInputSelectionStrategyBase {
+    constructor(dateDisplayPipe) {
+        super();
+        this.dateDisplayPipe = dateDisplayPipe;
+        this.selectionViewMode = 'day';
+        this.validViewModes = ['day', 'month', 'year'];
+        this.showSecondaryTextbox = false;
+        this.showSecondaryCalendar = false;
+    }
+    formatSelection(selection) {
+        // If the selection is a single date, format it into the first textbox.
+        if (DateInput.isSelectionSingleDate(selection)) {
+            return { textbox: this.dateDisplayPipe.transform(selection, true), textbox2: null };
+            // Otherwise, clear both textboxes. This shouldn't happen based on current date input flows,
+            // and even if it did there's not really a good way to handle it.
+        }
+        else {
+            return { textbox: null, textbox2: null };
+        }
+    }
+    parseTextboxValues(value, parseFormats, opts) {
+        return this.parseString(value.textbox, parseFormats, opts);
+    }
+    getSelectionFromDate(date) {
+        // Nice and simple
+        return date;
+    }
+    getNewSelectionFromExisting(previousSelection) {
+        // If the previous selection was a range, return the end date and default to the start date if there isn't one.
+        if (DateInput.isSelectionRange(previousSelection)) {
+            return previousSelection.end || previousSelection.start;
+            // If the previous selection was a single date, return it.
+        }
+        else if (DateInput.isSelectionSingleDate(previousSelection)) {
+            return previousSelection;
+        }
+        return null;
+    }
+    getNextSelection(selection) {
+        // Add a single day to the selection
+        if (DateInput.isSelectionSingleDate(selection)) {
+            return moment(selection).add(1, 'day').toDate();
+        }
+        // This shouldn't happen based on current date input flows, but if it does just return the selection as-is.
+        return selection;
+    }
+    getPreviousSelection(selection) {
+        // Subtract a single day from the selection
+        if (DateInput.isSelectionSingleDate(selection)) {
+            return moment(selection).subtract(1, 'day').toDate();
+        }
+        // This shouldn't happen based on current date input flows, but if it does just return the selection as-is.
+        return selection;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/controls/date-input/date-input-selection-strategies/last-28-days-selection-strategy.mjs

@@ -0,0 +1,100 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+import { DateInputSelectionStrategyBase } from "./date-input-selection-strategy-base";
+/**
+ * Selection strategy for the 'last 28 days' selection mode.
+ */
+export class Last28DaysSelectionStrategy extends DateInputSelectionStrategyBase {
+    constructor(rangeStrategy) {
+        super();
+        this.rangeStrategy = rangeStrategy;
+        this.selectionViewMode = 'day';
+        this.validViewModes = ['day', 'month', 'year'];
+        this.showSecondaryTextbox = true;
+        this.showSecondaryCalendar = false;
+    }
+    formatSelection(value) {
+        // Delegate to the range strategy for formatting since the logic is the same
+        return this.rangeStrategy.formatSelection(value);
+    }
+    parseTextboxValues(value, parseFormats, opts) {
+        let start = this.parseString(value.textbox, parseFormats, opts);
+        let end = this.parseString(value.textbox2, parseFormats, opts);
+        if (start && end) {
+            // Even if both dates are provided, it's possible that they don't match a 28-day range
+            // Update the start and end dates to match a 28-day range, keying off the end date if parseFromEnd is true
+            // parseFromEnd is true when a date is being entered from the end date textbox
+            if (opts?.parseFromEnd) {
+                start = moment(end).subtract(27, 'days').toDate();
+            }
+            else {
+                end = moment(start).add(27, 'days').toDate();
+            }
+        }
+        // If the start date is not provided, we'll use the end date to calculate the start date
+        if (!start && end && !opts?.preventAutoComplete) {
+            start = moment(end).subtract(27, 'days').toDate();
+        }
+        // If the end date is not provided, we'll use the start date to calculate the end date
+        if (!end && start && !opts?.preventAutoComplete) {
+            end = moment(start).add(27, 'days').toDate();
+        }
+        if (!start && !end) {
+            return null;
+        }
+        else {
+            return { start, end };
+        }
+    }
+    getSelectionFromDate(date) {
+        return {
+            start: moment(date).subtract(27, 'days').toDate(),
+            end: date
+        };
+    }
+    getNewSelectionFromExisting(previousSelection) {
+        if (DateInput.isSelectionRange(previousSelection)) {
+            // If the range only has a start date, make the 28-day range start on that date
+            if (!previousSelection.end && previousSelection.start) {
+                return {
+                    start: previousSelection.start,
+                    end: moment(previousSelection.start).add(27, 'days').toDate()
+                };
+                // If the range only has an end date, make the 28-day range end on that date
+            }
+            else if (previousSelection.end) {
+                return this.getSelectionFromDate(previousSelection.end);
+            }
+            // If the previous selection was a single date, make the range the 28 days ending on that date
+        }
+        else if (DateInput.isSelectionSingleDate(previousSelection)) {
+            return this.getSelectionFromDate(previousSelection);
+        }
+        return null;
+    }
+    getNextSelection(selection) {
+        // Move the selection to the next 28 days
+        if (DateInput.isSelectionRange(selection) && selection.end) {
+            return {
+                start: moment(selection.end).add(1, 'day').toDate(),
+                end: moment(selection.end).add(28, 'days').toDate()
+            };
+        }
+        // This shouldn't happen since the next stepper is disabled if the selection only has one date.
+        // Just return the selection as-is in this case.
+        return selection;
+    }
+    getPreviousSelection(selection) {
+        // Move the selection to the previous 28 days
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            return {
+                start: moment(selection.start).subtract(28, 'days').toDate(),
+                end: moment(selection.start).subtract(1, 'day').toDate()
+            };
+        }
+        // This shouldn't happen since the previous stepper is disabled if the selection only has one date.
+        // Just return the selection as-is in this case.
+        return selection;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"last-28-days-selection-strategy.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/controls/date-input/date-input-selection-strategies/last-28-days-selection-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from \"moment\";\r\nimport { Calendar } from \"../../calendar/calendar.types\";\r\nimport { DateInput } from \"../date-input.types\";\r\nimport { DateInputSelectionStrategyBase } from \"./date-input-selection-strategy-base\";\r\nimport { RangeSelectionStrategy } from \"./range-selection-strategy\";\r\n\r\n/**\r\n * Selection strategy for the 'last 28 days' selection mode.\r\n */\r\nexport class Last28DaysSelectionStrategy extends DateInputSelectionStrategyBase {\r\n  public readonly selectionViewMode: Calendar.ViewMode = 'day';\r\n  public readonly validViewModes: Calendar.ViewMode[] = ['day', 'month', 'year'];\r\n  public readonly showSecondaryTextbox = true;\r\n  public readonly showSecondaryCalendar = false;\r\n\r\n  constructor(\r\n    private rangeStrategy: RangeSelectionStrategy\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  formatSelection(value?: DateInput.Selection | null): DateInput.TextboxGroup['value'] {\r\n    // Delegate to the range strategy for formatting since the logic is the same\r\n    return this.rangeStrategy.formatSelection(value);\r\n  }\r\n\r\n  parseTextboxValues(value: DateInput.TextboxGroup['value'], parseFormats: string[], opts?: DateInput.ParsingOptions): DateInput.Selection | null {\r\n    let start = this.parseString(value.textbox, parseFormats, opts);\r\n    let end = this.parseString(value.textbox2, parseFormats, opts);\r\n\r\n    if (start && end) {\r\n      // Even if both dates are provided, it's possible that they don't match a 28-day range\r\n      // Update the start and end dates to match a 28-day range, keying off the end date if parseFromEnd is true\r\n      // parseFromEnd is true when a date is being entered from the end date textbox\r\n      if (opts?.parseFromEnd) {\r\n        start = moment(end).subtract(27, 'days').toDate();\r\n      } else {\r\n        end = moment(start).add(27, 'days').toDate();\r\n      }\r\n    }\r\n\r\n    // If the start date is not provided, we'll use the end date to calculate the start date\r\n    if (!start && end && !opts?.preventAutoComplete) {\r\n      start = moment(end).subtract(27, 'days').toDate();\r\n    }\r\n\r\n    // If the end date is not provided, we'll use the start date to calculate the end date\r\n    if (!end && start && !opts?.preventAutoComplete) {\r\n      end = moment(start).add(27, 'days').toDate();\r\n    }\r\n\r\n    if (!start && !end) {\r\n      return null;\r\n    } else {\r\n      return { start, end };\r\n    }\r\n  }\r\n\r\n  getSelectionFromDate(date: Date): DateInput.Selection | null {\r\n    return { \r\n      start: moment(date).subtract(27, 'days').toDate(),\r\n      end: date\r\n    };\r\n  }\r\n\r\n  getNewSelectionFromExisting(previousSelection?: DateInput.Selection): DateInput.Selection | null {\r\n    if (DateInput.isSelectionRange(previousSelection)) {\r\n      // If the range only has a start date, make the 28-day range start on that date\r\n      if (!previousSelection.end && previousSelection.start) {\r\n        return {\r\n          start: previousSelection.start,\r\n          end: moment(previousSelection.start).add(27, 'days').toDate()\r\n        };\r\n      // If the range only has an end date, make the 28-day range end on that date\r\n      } else if (previousSelection.end) {\r\n        return this.getSelectionFromDate(previousSelection.end);\r\n      }\r\n    // If the previous selection was a single date, make the range the 28 days ending on that date\r\n    } else if (DateInput.isSelectionSingleDate(previousSelection)) {\r\n      return this.getSelectionFromDate(previousSelection);\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  getNextSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Move the selection to the next 28 days\r\n    if (DateInput.isSelectionRange(selection) && selection.end) {\r\n      return {\r\n        start: moment(selection.end).add(1, 'day').toDate(),\r\n        end: moment(selection.end).add(28, 'days').toDate()\r\n      };\r\n    }\r\n\r\n    // This shouldn't happen since the next stepper is disabled if the selection only has one date.\r\n    // Just return the selection as-is in this case.\r\n    return selection;\r\n  }\r\n\r\n  getPreviousSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Move the selection to the previous 28 days\r\n    if (DateInput.isSelectionRange(selection) && selection.start) {\r\n      return {\r\n        start: moment(selection.start).subtract(28, 'days').toDate(),\r\n        end: moment(selection.start).subtract(1, 'day').toDate()\r\n      };\r\n    }\r\n\r\n    // This shouldn't happen since the previous stepper is disabled if the selection only has one date.\r\n    // Just return the selection as-is in this case.\r\n    return selection;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/controls/date-input/date-input-selection-strategies/last-7-days-selection-strategy.mjs

@@ -0,0 +1,101 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+import { DateInputSelectionStrategyBase } from "./date-input-selection-strategy-base";
+/**
+ * Selection strategy for the 'last 7 days' selection mode.
+ */
+export class Last7DaysSelectionStrategy extends DateInputSelectionStrategyBase {
+    constructor(rangeStrategy) {
+        super();
+        this.rangeStrategy = rangeStrategy;
+        this.selectionViewMode = 'day';
+        this.validViewModes = ['day', 'month', 'year'];
+        this.showSecondaryTextbox = true;
+        this.showSecondaryCalendar = false;
+    }
+    formatSelection(value) {
+        // Delegate to the range strategy for formatting since the logic is the same
+        return this.rangeStrategy.formatSelection(value);
+    }
+    parseTextboxValues(value, parseFormats, opts) {
+        let start = this.parseString(value.textbox, parseFormats, opts);
+        let end = this.parseString(value.textbox2, parseFormats, opts);
+        if (start && end) {
+            // Even if both dates are provided, it's possible that they don't match a 7-day range
+            // Update the start and end dates to match a 7-day range, keying off the end date if parseFromEnd is true
+            // parseFromEnd is true when a date is being entered from the end date textbox
+            if (opts?.parseFromEnd) {
+                start = moment(end).subtract(6, 'days').toDate();
+            }
+            else {
+                end = moment(start).add(6, 'days').toDate();
+            }
+        }
+        // If the start date is not provided, we'll use the end date to calculate the start date
+        if (!start && end && !opts?.preventAutoComplete) {
+            start = moment(end).subtract(6, 'days').toDate();
+        }
+        // If the end date is not provided, we'll use the start date to calculate the end date
+        if (!end && start && !opts?.preventAutoComplete) {
+            end = moment(start).add(6, 'days').toDate();
+        }
+        if (!start && !end) {
+            return null;
+        }
+        else {
+            return { start, end };
+        }
+    }
+    getSelectionFromDate(date) {
+        // Base the selection on the given date, moving back 6 days
+        return {
+            start: moment(date).subtract(6, 'days').toDate(),
+            end: date
+        };
+    }
+    getNewSelectionFromExisting(previousSelection) {
+        if (DateInput.isSelectionRange(previousSelection)) {
+            // If we don't have an end date, create the new selection based on the start date forwards
+            if (!previousSelection.end && previousSelection.start) {
+                return {
+                    start: previousSelection.start,
+                    end: moment(previousSelection.start).add(6, 'days').toDate()
+                };
+                // Otherwise, create the new selection based on the end date backwards
+            }
+            else if (previousSelection.end) {
+                return this.getSelectionFromDate(previousSelection.end);
+            }
+            // If we only have a single date, create the new selection based on that date backwards
+        }
+        else if (DateInput.isSelectionSingleDate(previousSelection)) {
+            return this.getSelectionFromDate(previousSelection);
+        }
+        return null;
+    }
+    getNextSelection(selection) {
+        // Shift the range forward by 7 days
+        if (DateInput.isSelectionRange(selection) && selection.end) {
+            return {
+                start: moment(selection.end).add(1, 'day').toDate(),
+                end: moment(selection.end).add(7, 'days').toDate()
+            };
+        }
+        // This shouldn't happen since the next stepper is disabled if the selection only has one date.
+        // Just return the selection as-is in this case.
+        return selection;
+    }
+    getPreviousSelection(selection) {
+        // Shift the range back 7 days
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            return {
+                start: moment(selection.start).subtract(7, 'days').toDate(),
+                end: moment(selection.start).subtract(1, 'day').toDate()
+            };
+        }
+        // This shouldn't happen since the previous stepper is disabled if the selection only has one date.
+        // Just return the selection as-is in this case.
+        return selection;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"last-7-days-selection-strategy.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/controls/date-input/date-input-selection-strategies/last-7-days-selection-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from \"moment\";\r\nimport { Calendar } from \"../../calendar/calendar.types\";\r\nimport { DateInput } from \"../date-input.types\";\r\nimport { DateInputSelectionStrategyBase } from \"./date-input-selection-strategy-base\";\r\nimport { RangeSelectionStrategy } from \"./range-selection-strategy\";\r\n\r\n/**\r\n * Selection strategy for the 'last 7 days' selection mode.\r\n */\r\nexport class Last7DaysSelectionStrategy extends DateInputSelectionStrategyBase {\r\n  public readonly selectionViewMode: Calendar.ViewMode = 'day';\r\n  public readonly validViewModes: Calendar.ViewMode[] = ['day', 'month', 'year'];\r\n  public readonly showSecondaryTextbox = true;\r\n  public readonly showSecondaryCalendar = false;\r\n\r\n  constructor(\r\n    private rangeStrategy: RangeSelectionStrategy\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  formatSelection(value?: DateInput.Selection | null): DateInput.TextboxGroup['value'] {\r\n    // Delegate to the range strategy for formatting since the logic is the same\r\n    return this.rangeStrategy.formatSelection(value);\r\n  }\r\n\r\n  parseTextboxValues(value: DateInput.TextboxGroup['value'], parseFormats: string[], opts?: DateInput.ParsingOptions): DateInput.Selection | null {\r\n    let start = this.parseString(value.textbox, parseFormats, opts);\r\n    let end = this.parseString(value.textbox2, parseFormats, opts);\r\n\r\n    if (start && end) {\r\n      // Even if both dates are provided, it's possible that they don't match a 7-day range\r\n      // Update the start and end dates to match a 7-day range, keying off the end date if parseFromEnd is true\r\n      // parseFromEnd is true when a date is being entered from the end date textbox\r\n      if (opts?.parseFromEnd) {\r\n        start = moment(end).subtract(6, 'days').toDate();\r\n      } else {\r\n        end = moment(start).add(6, 'days').toDate();\r\n      }\r\n    }\r\n\r\n    // If the start date is not provided, we'll use the end date to calculate the start date\r\n    if (!start && end && !opts?.preventAutoComplete) {\r\n      start = moment(end).subtract(6, 'days').toDate();\r\n    }\r\n\r\n    // If the end date is not provided, we'll use the start date to calculate the end date\r\n    if (!end && start && !opts?.preventAutoComplete) {\r\n      end = moment(start).add(6, 'days').toDate();\r\n    }\r\n\r\n    if (!start && !end) {\r\n      return null;\r\n    } else {\r\n      return { start, end };\r\n    }\r\n  }\r\n\r\n  getSelectionFromDate(date: Date): DateInput.Selection | null {\r\n    // Base the selection on the given date, moving back 6 days\r\n    return {\r\n      start: moment(date).subtract(6, 'days').toDate(),\r\n      end: date\r\n    };\r\n  }\r\n\r\n  getNewSelectionFromExisting(previousSelection?: DateInput.Selection | null): DateInput.Selection | null {\r\n    if (DateInput.isSelectionRange(previousSelection)) {\r\n      // If we don't have an end date, create the new selection based on the start date forwards\r\n      if (!previousSelection.end && previousSelection.start) {\r\n        return {\r\n          start: previousSelection.start,\r\n          end: moment(previousSelection.start).add(6, 'days').toDate()\r\n        };\r\n      // Otherwise, create the new selection based on the end date backwards\r\n      } else if (previousSelection.end) {\r\n        return this.getSelectionFromDate(previousSelection.end);\r\n      }\r\n    // If we only have a single date, create the new selection based on that date backwards\r\n    } else if (DateInput.isSelectionSingleDate(previousSelection)) {\r\n      return this.getSelectionFromDate(previousSelection);\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  getNextSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Shift the range forward by 7 days\r\n    if (DateInput.isSelectionRange(selection) && selection.end) {\r\n      return {\r\n        start: moment(selection.end).add(1, 'day').toDate(),\r\n        end: moment(selection.end).add(7, 'days').toDate()\r\n      };\r\n    }\r\n\r\n    // This shouldn't happen since the next stepper is disabled if the selection only has one date.\r\n    // Just return the selection as-is in this case.\r\n    return selection;\r\n  }\r\n\r\n  getPreviousSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Shift the range back 7 days\r\n    if (DateInput.isSelectionRange(selection) && selection.start) {\r\n      return {\r\n        start: moment(selection.start).subtract(7, 'days').toDate(),\r\n        end: moment(selection.start).subtract(1, 'day').toDate()\r\n      };\r\n    }\r\n\r\n    // This shouldn't happen since the previous stepper is disabled if the selection only has one date.\r\n    // Just return the selection as-is in this case.\r\n    return selection;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/controls/date-input/date-input-selection-strategies/month-selection-strategy.mjs

@@ -0,0 +1,76 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+import { DateInputSelectionStrategyBase } from "./date-input-selection-strategy-base";
+/**
+ * Selection strategy for the 'month' selection mode.
+ */
+export class MonthSelectionStrategy extends DateInputSelectionStrategyBase {
+    constructor() {
+        super(...arguments);
+        this.selectionViewMode = 'month';
+        this.validViewModes = ['month', 'year'];
+        this.showSecondaryTextbox = false;
+        this.showSecondaryCalendar = false;
+    }
+    formatSelection(selection) {
+        if (!selection) {
+            return { textbox: null, textbox2: null };
+        }
+        // We only need one date in the range to format since it only spans one month
+        // A single date selection shouldn't happen in this mode but it's simple enough to handle
+        const date = DateInput.isSelectionRange(selection) ? selection.start : selection;
+        return {
+            textbox: moment(date).format('MMM, YYYY'),
+            textbox2: null
+        };
+    }
+    parseTextboxValues(value, parseFormats, opts) {
+        // Only one textbox is used in this mode
+        const date = this.parseString(value.textbox, parseFormats, opts);
+        if (!date) {
+            return null;
+        }
+        return this.getSelectionFromDate(date);
+    }
+    getSelectionFromDate(date) {
+        return {
+            start: moment(date).startOf('month').toDate(),
+            end: moment(date).endOf('month').toDate()
+        };
+    }
+    getNewSelectionFromExisting(previousSelection) {
+        if (DateInput.isSelectionRange(previousSelection)) {
+            // We'll use the existing selection's end date and fall back to the start date if it's not available
+            const date = previousSelection.end || previousSelection.start;
+            if (date) {
+                return this.getSelectionFromDate(date);
+            }
+        }
+        else if (DateInput.isSelectionSingleDate(previousSelection)) {
+            // If the previous selection was a single date, make the range that month
+            return this.getSelectionFromDate(previousSelection);
+        }
+        return null;
+    }
+    getNextSelection(selection) {
+        // Move the selection to the next month
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            const date = moment(selection.start).add(1, 'month');
+            return this.getSelectionFromDate(date.toDate());
+        }
+        // This shouldn't happen since the next stepper is disabled if the selection only has one date.
+        // If it does, just return the selection as-is.
+        return selection;
+    }
+    getPreviousSelection(selection) {
+        // Move the selection to the previous month
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            const date = moment(selection.start).subtract(1, 'month');
+            return this.getSelectionFromDate(date.toDate());
+        }
+        // This shouldn't happen since the previous stepper is disabled if the selection only has one date.
+        // If it does, just return the selection as-is.
+        return selection;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"month-selection-strategy.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/controls/date-input/date-input-selection-strategies/month-selection-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from \"moment\";\r\nimport { Calendar } from \"../../calendar/calendar.types\";\r\nimport { DateInput } from \"../date-input.types\";\r\nimport { DateInputSelectionStrategyBase } from \"./date-input-selection-strategy-base\";\r\n\r\n/**\r\n * Selection strategy for the 'month' selection mode.\r\n */\r\nexport class MonthSelectionStrategy extends DateInputSelectionStrategyBase {\r\n  public readonly selectionViewMode: Calendar.ViewMode = 'month';\r\n  public readonly validViewModes: Calendar.ViewMode[] = ['month', 'year'];\r\n  public readonly showSecondaryTextbox = false;\r\n  public readonly showSecondaryCalendar = false;\r\n\r\n  formatSelection(selection?: DateInput.Selection | null): DateInput.TextboxGroup['value'] {\r\n    if (!selection) {\r\n      return { textbox: null, textbox2: null };\r\n    }\r\n\r\n    // We only need one date in the range to format since it only spans one month\r\n    // A single date selection shouldn't happen in this mode but it's simple enough to handle\r\n    const date = DateInput.isSelectionRange(selection) ? selection.start : selection;\r\n    return {\r\n      textbox: moment(date).format('MMM, YYYY'),\r\n      textbox2: null\r\n    };\r\n  }\r\n\r\n  parseTextboxValues(value: DateInput.TextboxGroup['value'], parseFormats: string[], opts?: DateInput.ParsingOptions): DateInput.Selection | null {\r\n    // Only one textbox is used in this mode\r\n    const date = this.parseString(value.textbox, parseFormats, opts);\r\n\r\n    if (!date) {\r\n      return null;\r\n    }\r\n\r\n    return this.getSelectionFromDate(date);\r\n  }\r\n\r\n  getSelectionFromDate(date: Date): DateInput.Selection | null {\r\n    return {\r\n      start: moment(date).startOf('month').toDate(),\r\n      end: moment(date).endOf('month').toDate()\r\n    };\r\n  }\r\n\r\n  getNewSelectionFromExisting(previousSelection?: DateInput.Selection): DateInput.Selection | null {\r\n    if (DateInput.isSelectionRange(previousSelection)) {\r\n      // We'll use the existing selection's end date and fall back to the start date if it's not available\r\n      const date = previousSelection.end || previousSelection.start;\r\n      if (date) {\r\n        return this.getSelectionFromDate(date);\r\n      }\r\n    } else if (DateInput.isSelectionSingleDate(previousSelection)) {\r\n      // If the previous selection was a single date, make the range that month\r\n      return this.getSelectionFromDate(previousSelection);\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  getNextSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Move the selection to the next month\r\n    if (DateInput.isSelectionRange(selection) && selection.start) { \r\n      const date = moment(selection.start).add(1, 'month');\r\n      return this.getSelectionFromDate(date.toDate());\r\n    }\r\n\r\n    // This shouldn't happen since the next stepper is disabled if the selection only has one date.\r\n    // If it does, just return the selection as-is.\r\n    return selection;\r\n  }\r\n\r\n  getPreviousSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Move the selection to the previous month\r\n    if (DateInput.isSelectionRange(selection) && selection.start) {\r\n      const date = moment(selection.start).subtract(1, 'month');\r\n      return this.getSelectionFromDate(date.toDate());\r\n    }\r\n\r\n    // This shouldn't happen since the previous stepper is disabled if the selection only has one date.\r\n    // If it does, just return the selection as-is.\r\n    return selection;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/controls/date-input/date-input-selection-strategies/quarter-selection-strategy.mjs

@@ -0,0 +1,79 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+import { DateInputSelectionStrategyBase } from "./date-input-selection-strategy-base";
+/**
+ * Selection strategy for the 'month' selection mode.
+ */
+export class QuarterSelectionStrategy extends DateInputSelectionStrategyBase {
+    constructor() {
+        super(...arguments);
+        this.selectionViewMode = 'quarter';
+        this.validViewModes = ['quarter', 'year'];
+        this.showSecondaryTextbox = false;
+        this.showSecondaryCalendar = false;
+    }
+    formatSelection(selection) {
+        // Format the the quarter range as "MMM–MMM, YYYY"
+        // We only have one textbox in this mode
+        if (DateInput.isSelectionRange(selection)) {
+            const start = moment(selection.start).format('MMM');
+            const end = moment(selection.end).format('MMM');
+            const year = moment(selection.end).format('YYYY');
+            return {
+                textbox: `${start}–${end}, ${year}`,
+                textbox2: null
+            };
+        }
+        // This shouldn't happen since the selection should always be a range in quarter mode
+        return { textbox: null, textbox2: null };
+    }
+    parseTextboxValues(value, parseFormats, opts) {
+        // Only one textbox is used in this mode
+        const date = this.parseString(value.textbox, parseFormats, opts);
+        if (!date) {
+            return null;
+        }
+        return this.getSelectionFromDate(date);
+    }
+    getSelectionFromDate(date) {
+        return {
+            start: moment(date).startOf('quarter').toDate(),
+            end: moment(date).endOf('quarter').toDate()
+        };
+    }
+    getNewSelectionFromExisting(previousSelection) {
+        if (DateInput.isSelectionRange(previousSelection)) {
+            // Base the quarter range off of the existing selection's end date, falling back to the start date
+            const date = previousSelection.end || previousSelection.start;
+            if (date) {
+                return this.getSelectionFromDate(date);
+            }
+        }
+        else if (DateInput.isSelectionSingleDate(previousSelection)) {
+            // If the previous selection was a single date, make the range that quarter
+            return this.getSelectionFromDate(previousSelection);
+        }
+        return null;
+    }
+    getNextSelection(selection) {
+        // Move the selection to the next quarter
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            const date = moment(selection.start).add(1, 'quarter');
+            return this.getSelectionFromDate(date.toDate());
+        }
+        // This shouldn't happen since the next stepper is disabled if the selection only has one date.
+        // If it does, just return the selection as-is.
+        return selection;
+    }
+    getPreviousSelection(selection) {
+        // Move the selection to the previous quarter
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            const date = moment(selection.start).subtract(1, 'quarter');
+            return this.getSelectionFromDate(date.toDate());
+        }
+        // This shouldn't happen since the previous stepper is disabled if the selection only has one date.
+        // If it does, just return the selection as-is.
+        return selection;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quarter-selection-strategy.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/controls/date-input/date-input-selection-strategies/quarter-selection-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,8BAA8B,EAAE,MAAM,sCAAsC,CAAC;AAEtF;;GAEG;AACH,MAAM,OAAO,wBAAyB,SAAQ,8BAA8B;IAA5E;;QACkB,sBAAiB,GAAsB,SAAS,CAAC;QACjD,mBAAc,GAAwB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAC1D,yBAAoB,GAAG,KAAK,CAAC;QAC7B,0BAAqB,GAAG,KAAK,CAAC;IA2EhD,CAAC;IAzEC,eAAe,CAAC,SAAsC;QACpD,kDAAkD;QAClD,wCAAwC;QACxC,IAAI,SAAS,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1C,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACpD,MAAM,GAAG,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAChD,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAClD,OAAO;gBACL,OAAO,EAAE,GAAG,KAAK,IAAI,GAAG,KAAK,IAAI,EAAE;gBACnC,QAAQ,EAAE,IAAI;aACf,CAAC;QACJ,CAAC;QAED,qFAAqF;QACrF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC3C,CAAC;IAED,kBAAkB,CAAC,KAAsC,EAAE,YAAsB,EAAE,IAA+B;QAChH,wCAAwC;QACxC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;QAEjE,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,oBAAoB,CAAC,IAAU;QAC7B,OAAO;YACL,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE;YAC/C,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE;SAC5C,CAAC;IACJ,CAAC;IAED,2BAA2B,CAAC,iBAAuC;QACjE,IAAI,SAAS,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAClD,kGAAkG;YAClG,MAAM,IAAI,GAAG,iBAAiB,CAAC,GAAG,IAAI,iBAAiB,CAAC,KAAK,CAAC;YAC9D,IAAI,IAAI,EAAE,CAAC;gBACT,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;QACH,CAAC;aAAM,IAAI,SAAS,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC9D,2EAA2E;YAC3E,OAAO,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,CAAC;QACtD,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gBAAgB,CAAC,SAAqC;QACpD,yCAAyC;QACzC,IAAI,SAAS,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;YAC7D,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACvD,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAClD,CAAC;QAED,+FAA+F;QAC/F,+CAA+C;QAC/C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,oBAAoB,CAAC,SAAqC;QACxD,6CAA6C;QAC7C,IAAI,SAAS,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;YAC7D,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YAC5D,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAClD,CAAC;QAED,mGAAmG;QACnG,+CAA+C;QAC/C,OAAO,SAAS,CAAC;IACnB,CAAC;CACF","sourcesContent":["import moment from \"moment\";\r\nimport { Calendar } from \"../../calendar/calendar.types\";\r\nimport { DateInput } from \"../date-input.types\";\r\nimport { DateInputSelectionStrategyBase } from \"./date-input-selection-strategy-base\";\r\n\r\n/**\r\n * Selection strategy for the 'month' selection mode.\r\n */\r\nexport class QuarterSelectionStrategy extends DateInputSelectionStrategyBase {\r\n  public readonly selectionViewMode: Calendar.ViewMode = 'quarter';\r\n  public readonly validViewModes: Calendar.ViewMode[] = ['quarter', 'year'];\r\n  public readonly showSecondaryTextbox = false;\r\n  public readonly showSecondaryCalendar = false;\r\n\r\n  formatSelection(selection?: DateInput.Selection | null): DateInput.TextboxGroup['value'] {\r\n    // Format the the quarter range as \"MMM–MMM, YYYY\"\r\n    // We only have one textbox in this mode\r\n    if (DateInput.isSelectionRange(selection)) {\r\n      const start = moment(selection.start).format('MMM');\r\n      const end = moment(selection.end).format('MMM');\r\n      const year = moment(selection.end).format('YYYY');\r\n      return {\r\n        textbox: `${start}–${end}, ${year}`,\r\n        textbox2: null\r\n      };\r\n    }\r\n    \r\n    // This shouldn't happen since the selection should always be a range in quarter mode\r\n    return { textbox: null, textbox2: null };\r\n  }\r\n\r\n  parseTextboxValues(value: DateInput.TextboxGroup['value'], parseFormats: string[], opts?: DateInput.ParsingOptions): DateInput.Selection | null {\r\n    // Only one textbox is used in this mode\r\n    const date = this.parseString(value.textbox, parseFormats, opts);\r\n    \r\n    if (!date) {\r\n      return null;\r\n    }\r\n\r\n    return this.getSelectionFromDate(date);\r\n  }\r\n\r\n  getSelectionFromDate(date: Date): DateInput.Selection | null {\r\n    return {\r\n      start: moment(date).startOf('quarter').toDate(),\r\n      end: moment(date).endOf('quarter').toDate()\r\n    };\r\n  }\r\n\r\n  getNewSelectionFromExisting(previousSelection?: DateInput.Selection): DateInput.Selection | null {\r\n    if (DateInput.isSelectionRange(previousSelection)) {\r\n      // Base the quarter range off of the existing selection's end date, falling back to the start date\r\n      const date = previousSelection.end || previousSelection.start;\r\n      if (date) {\r\n        return this.getSelectionFromDate(date);\r\n      }\r\n    } else if (DateInput.isSelectionSingleDate(previousSelection)) {\r\n      // If the previous selection was a single date, make the range that quarter\r\n      return this.getSelectionFromDate(previousSelection);\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  getNextSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Move the selection to the next quarter\r\n    if (DateInput.isSelectionRange(selection) && selection.start) {\r\n      const date = moment(selection.start).add(1, 'quarter');\r\n      return this.getSelectionFromDate(date.toDate());\r\n    }\r\n\r\n    // This shouldn't happen since the next stepper is disabled if the selection only has one date.\r\n    // If it does, just return the selection as-is.\r\n    return selection;\r\n  }\r\n\r\n  getPreviousSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // Move the selection to the previous quarter\r\n    if (DateInput.isSelectionRange(selection) && selection.start) {\r\n      const date = moment(selection.start).subtract(1, 'quarter');\r\n      return this.getSelectionFromDate(date.toDate());\r\n    }\r\n\r\n    // This shouldn't happen since the previous stepper is disabled if the selection only has one date.\r\n    // If it does, just return the selection as-is.\r\n    return selection;\r\n  }\r\n}\r\n"]}