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

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

@@ -0,0 +1,210 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+import { DateInputSelectionStrategyBase } from "./date-input-selection-strategy-base";
+/**
+ * Selection strategy for the 'range' selection mode.
+ */
+export class RangeSelectionStrategy extends DateInputSelectionStrategyBase {
+    constructor() {
+        super(...arguments);
+        this.selectionViewMode = 'day';
+        this.validViewModes = ['day', 'month', 'year'];
+        this.showSecondaryTextbox = true;
+        this.showSecondaryCalendar = true;
+    }
+    formatSelection(selection) {
+        if (!selection) {
+            return { textbox: null, textbox2: null };
+        }
+        // We use the 'll' moment medium format here to make sure the formatted date is formatted according to the user's locale
+        if (DateInput.isSelectionSingleDate(selection)) {
+            return { textbox: moment(selection).format('ll'), textbox2: null };
+        }
+        else {
+            const start = selection.start ? moment(selection.start).format('ll') : null;
+            const end = selection.end ? moment(selection.end).format('ll') : null;
+            return { textbox: start, textbox2: end };
+        }
+    }
+    parseTextboxValues(value, parseFormats, opts) {
+        let start = this.parseString(value.textbox, parseFormats, opts);
+        let end = this.parseString(value.textbox2, parseFormats, opts);
+        // If the start date is after the end date, we need to clear out the invalid date. This is different from the last 7/28 days strategies
+        // because we don't have a fixed range to automatically adjust the dates to. If the user is changing the begin date or end date and ends
+        // up crossing the other date, we should clear out the date that's not being changed so that the user can enter a valid range using the
+        // begin/end date they just entered.
+        if (start && end && moment(start).isAfter(end)) {
+            if (opts?.parseFromEnd) {
+                start = null;
+            }
+            else {
+                end = null;
+            }
+        }
+        if (!start && !end) {
+            return null;
+        }
+        else {
+            return { start, end };
+        }
+    }
+    getSelectionFromDate(date, existingSelection) {
+        if (DateInput.isSelectionRange(existingSelection)) {
+            const { start, end } = existingSelection;
+            if (start && !end) {
+                // If the selected date is before the existing start date, set it as the new start date and use the existing start date as the end date
+                return moment(date).isBefore(start) ? { start: date, end: start } : { start, end: date };
+            }
+            if (end && !start) {
+                // If the selected date is after the existing end date, set it as the new end date and use the existing end date as the start date
+                return moment(date).isBefore(end) ? { start: date, end } : { start: end, end: date };
+            }
+        }
+        else if (DateInput.isSelectionSingleDate(existingSelection)) {
+            // If the selected date is before the existing date, set it as the new start date and use the existing date as the end date
+            return moment(date).isBefore(existingSelection) ? { start: date, end: existingSelection } : { start: existingSelection, end: date };
+        }
+        // If no selection exists or we already have a complete selection, start a new one with the selected date as the start date.
+        return { start: date, end: null };
+    }
+    getNewSelectionFromExisting(previousSelection) {
+        if (DateInput.isSelectionRange(previousSelection)) {
+            // If we have a range, just return it as is. We don't have a fixed range to adjust the dates to.
+            // Even if it's incomplete, the user will still be able to select the remaining date.
+            return previousSelection;
+        }
+        else if (DateInput.isSelectionSingleDate(previousSelection)) {
+            // If we have a single date selection, use it as the start date for the new one.
+            return { start: previousSelection, end: null };
+        }
+        return null;
+    }
+    getSelectionForQuickSelectDate(date, existingSelection) {
+        // If we have a valid range, we'll shift the range to the date provided, using it as the end date
+        // The new selection will have the same length as the previous.
+        if (DateInput.isSelectionRange(existingSelection) && existingSelection.start && existingSelection.end) {
+            const length = moment(existingSelection.end).diff(existingSelection.start, 'days');
+            return {
+                start: moment(date).subtract(length, 'days').toDate(),
+                end: date
+            };
+        }
+        // If we only have a single date, we'll use the date provided as the end date.
+        // The user will be able to select the start date.
+        return { start: null, end: date };
+    }
+    getNextSelection(selection) {
+        // We can only determine the next selection if we have a valid range
+        if (DateInput.isSelectionRange(selection) && selection.start && selection.end) {
+            // Shift the range forward by the number of days between the start and end dates
+            const length = moment(selection.end).diff(selection.start, 'days');
+            return {
+                start: moment(selection.end).add(1, 'days').toDate(),
+                end: moment(selection.end).add(1 + length, 'days').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) {
+        // We can only determine the previous selection if we have a valid range
+        if (DateInput.isSelectionRange(selection) && selection.start && selection.end) {
+            // Shift the range back by the number of days between the start and end dates
+            const length = moment(selection.end).diff(selection.start, 'days');
+            return {
+                start: moment(selection.start).subtract(1 + length, 'days').toDate(),
+                end: moment(selection.start).subtract(1, 'days').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;
+    }
+    getPrimaryCalendarView(selection, minDate, maxDate, currentView) {
+        let viewDate;
+        if (DateInput.isSelectionRange(selection)) {
+            let start = selection.start ? moment(selection.start) : null;
+            let end = selection.end ? moment(selection.end) : null;
+            // Since we're in range mode, the primary calendar is mostly concerned with the start date
+            if (start) {
+                // If we have a start date in the selection and it's before the min date, shift the view to the min date.
+                if (start.isBefore(minDate, 'month')) {
+                    viewDate = minDate;
+                    // If the start is after the max date, shift the view to the max date.
+                }
+                else if (start.isSameOrAfter(maxDate, 'month')) {
+                    // the secondary calendar will show the max date month.
+                    // The primary calendar will show the month before the max date.
+                    viewDate = moment(maxDate).subtract(1, 'month').toDate();
+                }
+                else {
+                    viewDate = start.toDate();
+                }
+            }
+            else if (end && end.isSameOrBefore(minDate, 'month')) {
+                // If we don't have a start date, and the end date is the same month or before the min date, shift the view to the min date.
+                viewDate = minDate;
+            }
+            else if (end && end.isSameOrBefore(new Date(), 'month')) {
+                // If we don't have a start date, and the end date is the same month or before the current month, shift the view to the month before the end
+                viewDate = moment(end).subtract(1, 'month').toDate();
+            }
+            else {
+                // Otherwise, show the current month.
+                viewDate = new Date();
+            }
+        }
+        else {
+            viewDate = selection || new 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: viewDate };
+    }
+    getSecondaryCalendarView(selection, minDate, maxDate, currentView) {
+        let viewDate;
+        if (DateInput.isSelectionRange(selection)) {
+            let start = selection.start ? moment(selection.start) : null;
+            let end = selection.end ? moment(selection.end) : null;
+            // The secondary calendar is primarily concerned with the end date in the selection.
+            if (end) {
+                if (end.isAfter(maxDate, 'month')) {
+                    // If the end date is after the max date, shift the view to the max date.
+                    viewDate = maxDate;
+                }
+                else if (end.isSameOrBefore(minDate, 'month')) {
+                    // If the end date is the same month or before the min date, shift the view to show
+                    // the month after the min date. The primary calendar will show the min date month.
+                    viewDate = moment(minDate).add(1, 'month').toDate();
+                }
+                else {
+                    // Otherwise, show the end date month.
+                    viewDate = end.toDate();
+                }
+            }
+            else if (start && start.isSameOrAfter(maxDate, 'month')) {
+                // If we don't have an end date, and the start date is after the max date, show the max date month
+                viewDate = maxDate;
+            }
+            else if (start && start.isSameOrAfter(new Date(), 'month')) {
+                // If we don't have an end date, and the start date is on or after the current month,
+                // show the month after the start date.
+                viewDate = moment(start).add(1, 'month').toDate();
+            }
+            else {
+                // Otherwise, show the current month.
+                viewDate = new Date();
+            }
+        }
+        else {
+            viewDate = selection || new 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: viewDate };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range-selection-strategy.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/controls/date-input/date-input-selection-strategies/range-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 'range' selection mode.\r\n */\r\nexport class RangeSelectionStrategy 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 = true;\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 use the 'll' moment medium format here to make sure the formatted date is formatted according to the user's locale\r\n    if (DateInput.isSelectionSingleDate(selection)) {\r\n      return { textbox: moment(selection).format('ll'), textbox2: null };\r\n    } else {\r\n      const start = selection.start ? moment(selection.start).format('ll') : null;\r\n      const end = selection.end ? moment(selection.end).format('ll') : null;\r\n\r\n      return { textbox: start, textbox2: end };\r\n    }\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 the start date is after the end date, we need to clear out the invalid date. This is different from the last 7/28 days strategies\r\n    // because we don't have a fixed range to automatically adjust the dates to. If the user is changing the begin date or end date and ends\r\n    // up crossing the other date, we should clear out the date that's not being changed so that the user can enter a valid range using the\r\n    // begin/end date they just entered.\r\n    if (start && end && moment(start).isAfter(end)) {\r\n      if (opts?.parseFromEnd) {\r\n        start = null;\r\n      } else {\r\n        end = null;\r\n      }\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, existingSelection: DateInput.Selection | null): DateInput.Selection | null {\r\n    if (DateInput.isSelectionRange(existingSelection)) {\r\n      const { start, end } = existingSelection;\r\n      if (start && !end) {\r\n        // If the selected date is before the existing start date, set it as the new start date and use the existing start date as the end date\r\n        return moment(date).isBefore(start) ? { start: date, end: start } : { start, end: date };\r\n      }\r\n      if (end && !start) {\r\n        // If the selected date is after the existing end date, set it as the new end date and use the existing end date as the start date\r\n        return moment(date).isBefore(end) ? { start: date, end } : { start: end, end: date };\r\n      }\r\n    } else if (DateInput.isSelectionSingleDate(existingSelection)) {\r\n      // If the selected date is before the existing date, set it as the new start date and use the existing date as the end date\r\n      return moment(date).isBefore(existingSelection) ? { start: date, end: existingSelection } : { start: existingSelection, end: date };\r\n    }\r\n\r\n    // If no selection exists or we already have a complete selection, start a new one with the selected date as the start date.\r\n    return { start: date, end: null };\r\n  }\r\n\r\n  getNewSelectionFromExisting(previousSelection?: DateInput.Selection): DateInput.Selection | null {\r\n    if (DateInput.isSelectionRange(previousSelection)) {\r\n      // If we have a range, just return it as is. We don't have a fixed range to adjust the dates to.\r\n      // Even if it's incomplete, the user will still be able to select the remaining date.\r\n      return previousSelection;\r\n    } else if (DateInput.isSelectionSingleDate(previousSelection)) {\r\n      // If we have a single date selection, use it as the start date for the new one.\r\n      return { start: previousSelection, end: null };\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  getSelectionForQuickSelectDate(date: Date, existingSelection?: DateInput.Selection | null): DateInput.Selection | null {\r\n    // If we have a valid range, we'll shift the range to the date provided, using it as the end date\r\n    // The new selection will have the same length as the previous.\r\n    if (DateInput.isSelectionRange(existingSelection) && existingSelection.start && existingSelection.end) {\r\n      const length = moment(existingSelection.end).diff(existingSelection.start, 'days');\r\n      return {\r\n        start: moment(date).subtract(length, 'days').toDate(),\r\n        end: date\r\n      };\r\n    }\r\n\r\n    // If we only have a single date, we'll use the date provided as the end date.\r\n    // The user will be able to select the start date.\r\n    return { start: null, end: date };\r\n  }\r\n\r\n  getNextSelection(selection: DateInput.Selection | null): DateInput.Selection | null {\r\n    // We can only determine the next selection if we have a valid range\r\n    if (DateInput.isSelectionRange(selection) && selection.start && selection.end) {\r\n      // Shift the range forward by the number of days between the start and end dates\r\n      const length = moment(selection.end).diff(selection.start, 'days');\r\n      return {\r\n        start: moment(selection.end).add(1, 'days').toDate(),\r\n        end: moment(selection.end).add(1 + length, '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    // 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    // We can only determine the previous selection if we have a valid range\r\n    if (DateInput.isSelectionRange(selection) && selection.start && selection.end) {\r\n      // Shift the range back by the number of days between the start and end dates\r\n      const length = moment(selection.end).diff(selection.start, 'days');\r\n      return {\r\n        start: moment(selection.start).subtract(1 + length, 'days').toDate(),\r\n        end: moment(selection.start).subtract(1, 'days').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    // If it does, just return the selection as-is.\r\n    return selection;\r\n  }\r\n\r\n  getPrimaryCalendarView(selection: DateInput.Selection | null, minDate: Date, maxDate: Date, currentView: Calendar.View): Calendar.View {\r\n    let viewDate: Date;\r\n    if (DateInput.isSelectionRange(selection)) {\r\n      let start = selection.start ? moment(selection.start) : null;\r\n      let end = selection.end ? moment(selection.end) : null;\r\n\r\n      // Since we're in range mode, the primary calendar is mostly concerned with the start date\r\n      if (start) {\r\n        // If we have a start date in the selection and it's before the min date, shift the view to the min date.\r\n        if (start.isBefore(minDate, 'month')) {\r\n          viewDate = minDate;\r\n          // If the start is after the max date, shift the view to the max date.\r\n        } else if (start.isSameOrAfter(maxDate, 'month')) {\r\n          // the secondary calendar will show the max date month.\r\n          // The primary calendar will show the month before the max date.\r\n          viewDate = moment(maxDate).subtract(1, 'month').toDate();\r\n        } else {\r\n          viewDate = start.toDate();\r\n        }\r\n      } else if (end && end.isSameOrBefore(minDate, 'month')) {\r\n        // If we don't have a start date, and the end date is the same month or before the min date, shift the view to the min date.\r\n        viewDate = minDate;\r\n      } else if (end && end.isSameOrBefore(new Date(), 'month')) {\r\n        // If we don't have a start date, and the end date is the same month or before the current month, shift the view to the month before the end\r\n        viewDate = moment(end).subtract(1, 'month').toDate();\r\n      } else {\r\n        // Otherwise, show the current month.\r\n        viewDate = new Date();\r\n      }\r\n    } else {\r\n      viewDate = selection || new Date();\r\n    }\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: viewDate };\r\n  }\r\n\r\n  getSecondaryCalendarView(selection: DateInput.Selection | null, minDate: Date, maxDate: Date, currentView: Calendar.View): Calendar.View {\r\n    let viewDate: Date;\r\n\r\n    if (DateInput.isSelectionRange(selection)) {\r\n      let start = selection.start ? moment(selection.start) : null;\r\n      let end = selection.end ? moment(selection.end) : null;\r\n\r\n      // The secondary calendar is primarily concerned with the end date in the selection.\r\n      if (end) {\r\n        if (end.isAfter(maxDate, 'month')) {\r\n          // If the end date is after the max date, shift the view to the max date.\r\n          viewDate = maxDate;\r\n        } else if (end.isSameOrBefore(minDate, 'month')) {\r\n          // If the end date is the same month or before the min date, shift the view to show\r\n          // the month after the min date. The primary calendar will show the min date month.\r\n          viewDate = moment(minDate).add(1, 'month').toDate();\r\n        } else {\r\n          // Otherwise, show the end date month.\r\n          viewDate = end.toDate();\r\n        }\r\n      } else if (start && start.isSameOrAfter(maxDate, 'month')) {\r\n        // If we don't have an end date, and the start date is after the max date, show the max date month\r\n        viewDate = maxDate;\r\n      } else if (start && start.isSameOrAfter(new Date(), 'month')) {\r\n        // If we don't have an end date, and the start date is on or after the current month,\r\n        // show the month after the start date.\r\n        viewDate = moment(start).add(1, 'month').toDate();\r\n      } else {\r\n        // Otherwise, show the current month.\r\n        viewDate = new Date();\r\n      }\r\n    } else {\r\n      viewDate = selection || new Date();\r\n    }\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: viewDate };\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,81 @@
+import moment from "moment";
+import { DateInput } from "../date-input.types";
+import { DateInputSelectionStrategyBase } from "./date-input-selection-strategy-base";
+/**
+ * Selection strategy for the 'year' selection mode.
+ */
+export class YearSelectionStrategy extends DateInputSelectionStrategyBase {
+    constructor() {
+        super(...arguments);
+        this.selectionViewMode = 'year';
+        this.validViewModes = ['year'];
+        this.showSecondaryTextbox = false;
+        this.showSecondaryCalendar = false;
+    }
+    formatSelection(selection) {
+        if (!selection) {
+            return { textbox: null, textbox2: null };
+        }
+        // Only one date is needed for formatting since the ranges span a single year.
+        // There shouldn't be any case where there's only a single date but it's covered anyway.
+        const date = DateInput.isSelectionRange(selection) ? selection.start : selection;
+        return { textbox: moment(date).format('YYYY'), textbox2: null };
+    }
+    parseString(value, parseFormats, opts) {
+        // Including 'YY' and 'YYYY' as valid formats for year input. These aren't included in the default parse
+        // formats because they cause issues with the default date parsing.
+        return super.parseString(value, ['YY', 'YYYY', ...parseFormats], opts);
+    }
+    parseTextboxValues(value, parseFormats, opts) {
+        // Only a single textbox is used in year mode
+        const date = this.parseString(value.textbox, parseFormats, opts);
+        if (!date) {
+            return null;
+        }
+        return this.getSelectionFromDate(date);
+    }
+    getSelectionFromDate(date) {
+        return {
+            start: moment(date).startOf('year').toDate(),
+            end: moment(date).endOf('year').toDate()
+        };
+    }
+    getNewSelectionFromExisting(previousSelection) {
+        if (DateInput.isSelectionRange(previousSelection)) {
+            // Base the year 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 year
+            return this.getSelectionFromDate(previousSelection);
+        }
+        return null;
+    }
+    getSelectionForQuickSelectDate(date) {
+        return this.getSelectionFromDate(date);
+    }
+    getNextSelection(selection) {
+        // Move the selection to the next year
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            const date = moment(selection.start).add(1, 'year');
+            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 year
+        if (DateInput.isSelectionRange(selection) && selection.start) {
+            const date = moment(selection.start).subtract(1, 'year');
+            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":"year-selection-strategy.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/controls/date-input/date-input-selection-strategies/year-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 'year' selection mode.\r\n */\r\nexport class YearSelectionStrategy extends DateInputSelectionStrategyBase {\r\n  public readonly selectionViewMode: Calendar.ViewMode = 'year';\r\n  public readonly validViewModes: Calendar.ViewMode[] = ['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    // Only one date is needed for formatting since the ranges span a single year.\r\n    // There shouldn't be any case where there's only a single date but it's covered anyway.\r\n    const date = DateInput.isSelectionRange(selection) ? selection.start : selection;\r\n    return { textbox: moment(date).format('YYYY'), textbox2: null };\r\n  }\r\n\r\n  parseString(value: string | null | undefined, parseFormats: string[], opts?: DateInput.ParsingOptions): Date | null {\r\n    // Including 'YY' and 'YYYY' as valid formats for year input. These aren't included in the default parse\r\n    // formats because they cause issues with the default date parsing.\r\n    return super.parseString(value, ['YY', 'YYYY', ...parseFormats], opts);\r\n  }\r\n\r\n  parseTextboxValues(value: DateInput.TextboxGroup['value'], parseFormats: string[], opts?: DateInput.ParsingOptions): DateInput.Selection | null {\r\n    // Only a single textbox is used in year 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('year').toDate(),\r\n      end: moment(date).endOf('year').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 year 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 year\r\n      return this.getSelectionFromDate(previousSelection);\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  getSelectionForQuickSelectDate(date: Date): DateInput.Selection | null {\r\n    return this.getSelectionFromDate(date);\r\n  }\r\n\r\n  getNextSelection(selection: DateInput.Selection): DateInput.Selection | null {\r\n    // Move the selection to the next year\r\n    if (DateInput.isSelectionRange(selection) && selection.start) {\r\n      const date = moment(selection.start).add(1, 'year');\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): DateInput.Selection | null {\r\n    // Move the selection to the previous year\r\n    if (DateInput.isSelectionRange(selection) && selection.start) {\r\n      const date = moment(selection.start).subtract(1, 'year');\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"]}