react-day-picker 9.6.2 → 9.6.3

package/src/helpers/getDays.test.ts

@@ -0,0 +1,30 @@
+import { CalendarDay, CalendarWeek, CalendarMonth } from "../classes";
+
+import { getDays } from "./getDays";
+
+const days1 = [
+  new CalendarDay(new Date(2023, 1, 12), new Date(2023, 1, 1)),
+  new CalendarDay(new Date(2023, 1, 13), new Date(2023, 1, 1))
+];
+const days2 = [
+  new CalendarDay(new Date(2023, 1, 13), new Date(2023, 1, 1)),
+  new CalendarDay(new Date(2023, 1, 14), new Date(2023, 1, 1))
+];
+const days3 = [
+  new CalendarDay(new Date(2023, 2, 12), new Date(2023, 2, 1)),
+  new CalendarDay(new Date(2023, 2, 13), new Date(2023, 2, 1))
+];
+const days4 = [
+  new CalendarDay(new Date(2023, 2, 13), new Date(2023, 2, 1)),
+  new CalendarDay(new Date(2023, 2, 14), new Date(2023, 2, 1))
+];
+const weeks1 = [new CalendarWeek(1, days1), new CalendarWeek(2, days2)];
+const weeks2 = [new CalendarWeek(3, days3), new CalendarWeek(4, days4)];
+const months = [
+  new CalendarMonth(days1[0].date, weeks1),
+  new CalendarMonth(days1[0].date, weeks2)
+];
+
+it("should return all the days belonging to the calendar by merging the days in the weeks for each month", () => {
+  expect(getDays(months)).toEqual([...days1, ...days2, ...days3, ...days4]);
+});

package/src/helpers/getDays.ts

@@ -0,0 +1,16 @@
+import type { CalendarDay, CalendarMonth } from "../classes/index.js";
+
+/**
+ * Returns all the days belonging to the calendar by merging the days in the
+ * weeks for each month.
+ */
+export function getDays(calendarMonths: CalendarMonth[]) {
+  const initialDays: CalendarDay[] = [];
+  return calendarMonths.reduce((days, month) => {
+    const initialDays: CalendarDay[] = [];
+    const weekDays: CalendarDay[] = month.weeks.reduce((weekDays, week) => {
+      return [...weekDays, ...week.days];
+    }, initialDays);
+    return [...days, ...weekDays];
+  }, initialDays);
+}

package/src/helpers/getDefaultClassNames.test.ts

@@ -0,0 +1,47 @@
+import { getDefaultClassNames } from "./getDefaultClassNames";
+
+test("should return the default classnames", () => {
+  expect(getDefaultClassNames()).toStrictEqual({
+    button_next: "rdp-button_next",
+    button_previous: "rdp-button_previous",
+    root: "rdp-root",
+    caption_label: "rdp-caption_label",
+    chevron: "rdp-chevron",
+    day: "rdp-day",
+    day_button: "rdp-day_button",
+    disabled: "rdp-disabled",
+    dropdowns: "rdp-dropdowns",
+    dropdown_root: "rdp-dropdown_root",
+    dropdown: "rdp-dropdown",
+    focused: "rdp-focused",
+    footer: "rdp-footer",
+    hidden: "rdp-hidden",
+    month_caption: "rdp-month_caption",
+    month_grid: "rdp-month_grid",
+    month: "rdp-month",
+    weeks: "rdp-weeks",
+    months_dropdown: "rdp-months_dropdown",
+    months: "rdp-months",
+    nav: "rdp-nav",
+    outside: "rdp-outside",
+    range_end: "rdp-range_end",
+    range_middle: "rdp-range_middle",
+    range_start: "rdp-range_start",
+    selected: "rdp-selected",
+    today: "rdp-today",
+    week_number: "rdp-week_number",
+    week_number_header: "rdp-week_number_header",
+    week: "rdp-week",
+    weekday: "rdp-weekday",
+    weekdays: "rdp-weekdays",
+    years_dropdown: "rdp-years_dropdown",
+    caption_after_enter: "rdp-caption_after_enter",
+    caption_after_exit: "rdp-caption_after_exit",
+    caption_before_enter: "rdp-caption_before_enter",
+    caption_before_exit: "rdp-caption_before_exit",
+    weeks_after_enter: "rdp-weeks_after_enter",
+    weeks_after_exit: "rdp-weeks_after_exit",
+    weeks_before_enter: "rdp-weeks_before_enter",
+    weeks_before_exit: "rdp-weeks_before_exit"
+  });
+});

package/src/helpers/getDefaultClassNames.ts

@@ -0,0 +1,33 @@
+import { UI, DayFlag, SelectionState, Animation } from "../UI.js";
+import type { ClassNames } from "../types/index.js";
+
+/**
+ * Get the default class names for the UI elements.
+ *
+ * @group Utilities
+ */
+export function getDefaultClassNames(): ClassNames {
+  const classNames: Partial<Required<ClassNames>> = {};
+
+  for (const key in UI) {
+    classNames[UI[key as keyof typeof UI]] =
+      `rdp-${UI[key as keyof typeof UI]}`;
+  }
+
+  for (const key in DayFlag) {
+    classNames[DayFlag[key as keyof typeof DayFlag]] =
+      `rdp-${DayFlag[key as keyof typeof DayFlag]}`;
+  }
+
+  for (const key in SelectionState) {
+    classNames[SelectionState[key as keyof typeof SelectionState]] =
+      `rdp-${SelectionState[key as keyof typeof SelectionState]}`;
+  }
+
+  for (const key in Animation) {
+    classNames[Animation[key as keyof typeof Animation]] =
+      `rdp-${Animation[key as keyof typeof Animation]}`;
+  }
+
+  return classNames as Required<ClassNames>;
+}

package/src/helpers/getDisplayMonths.test.ts

@@ -0,0 +1,44 @@
+import { defaultDateLib } from "../classes/DateLib";
+
+import { getDisplayMonths } from "./getDisplayMonths";
+
+describe("getDisplayMonths", () => {
+  it("should return the months to display in the calendar", () => {
+    const firstMonth = new Date(2020, 0);
+    const expectedResult = [new Date(2020, 0)];
+    const result = getDisplayMonths(firstMonth, undefined, {}, defaultDateLib);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it("should return the months to display in the calendar when the number of months is greater than 1", () => {
+    const firstMonth = new Date(2020, 0);
+    const expectedResult = [
+      new Date(2020, 0),
+      new Date(2020, 1),
+      new Date(2020, 2)
+    ];
+    const result = getDisplayMonths(
+      firstMonth,
+      undefined,
+      {
+        numberOfMonths: 3
+      },
+      defaultDateLib
+    );
+    expect(result).toEqual(expectedResult);
+  });
+
+  it("should return the months to display in the calendar when passing a max date", () => {
+    const firstMonth = new Date(2020, 0);
+    const expectedResult = [new Date(2020, 0), new Date(2020, 1)];
+    const result = getDisplayMonths(
+      firstMonth,
+      new Date(2020, 1, 10),
+      {
+        numberOfMonths: 3
+      },
+      defaultDateLib
+    );
+    expect(result).toEqual(expectedResult);
+  });
+});

package/src/helpers/getDisplayMonths.ts

@@ -0,0 +1,20 @@
+import type { DateLib } from "../classes/DateLib.js";
+import type { DayPickerProps } from "../types/index.js";
+
+export function getDisplayMonths(
+  firstDisplayedMonth: Date,
+  calendarEndMonth: Date | undefined,
+  props: Pick<DayPickerProps, "numberOfMonths">,
+  dateLib: DateLib
+) {
+  const { numberOfMonths = 1 } = props;
+  const months: Date[] = [];
+  for (let i = 0; i < numberOfMonths; i++) {
+    const month = dateLib.addMonths(firstDisplayedMonth, i);
+    if (calendarEndMonth && month > calendarEndMonth) {
+      break;
+    }
+    months.push(month);
+  }
+  return months;
+}

package/src/helpers/getFocusableDate.ts

@@ -0,0 +1,59 @@
+import type { DateLib } from "../classes/DateLib.js";
+import type {
+  DayPickerProps,
+  MoveFocusBy,
+  MoveFocusDir
+} from "../types/index.js";
+
+/** Return the next date that should be focused. */
+export function getFocusableDate(
+  moveBy: MoveFocusBy,
+  moveDir: MoveFocusDir,
+  refDate: Date,
+  navStart: Date | undefined,
+  navEnd: Date | undefined,
+  props: Pick<DayPickerProps, "ISOWeek" | "broadcastCalendar">,
+  dateLib: DateLib
+): Date {
+  const { ISOWeek, broadcastCalendar } = props;
+  const {
+    addDays,
+    addMonths,
+    addWeeks,
+    addYears,
+    endOfBroadcastWeek,
+    endOfISOWeek,
+    endOfWeek,
+    max,
+    min,
+    startOfBroadcastWeek,
+    startOfISOWeek,
+    startOfWeek
+  } = dateLib;
+  const moveFns = {
+    day: addDays,
+    week: addWeeks,
+    month: addMonths,
+    year: addYears,
+    startOfWeek: (date: Date) =>
+      broadcastCalendar
+        ? startOfBroadcastWeek(date, dateLib)
+        : ISOWeek
+          ? startOfISOWeek(date)
+          : startOfWeek(date),
+    endOfWeek: (date: Date) =>
+      broadcastCalendar
+        ? endOfBroadcastWeek(date, dateLib)
+        : ISOWeek
+          ? endOfISOWeek(date)
+          : endOfWeek(date)
+  };
+
+  let focusableDate = moveFns[moveBy](refDate, moveDir === "after" ? 1 : -1);
+  if (moveDir === "before" && navStart) {
+    focusableDate = max([navStart, focusableDate]);
+  } else if (moveDir === "after" && navEnd) {
+    focusableDate = min([navEnd, focusableDate]);
+  }
+  return focusableDate;
+}

package/src/helpers/getFormatters.test.ts

@@ -0,0 +1,48 @@
+import * as defaultFormatters from "../formatters";
+
+import { getFormatters } from "./getFormatters";
+
+const customFormattersMock = {
+  formatMonthCaption: jest.fn(),
+  formatYearCaption: jest.fn()
+};
+
+test("returns default formatters when custom formatters are not provided", () => {
+  const formatters = getFormatters(undefined);
+  expect(formatters).toEqual(defaultFormatters);
+});
+
+test("merges custom formatters with default formatters", () => {
+  const formatters = getFormatters(customFormattersMock);
+  expect(formatters).toEqual(expect.objectContaining(customFormattersMock));
+});
+
+test("assigns `formatMonthCaption` to `formatCaption` if `formatCaption` is not defined", () => {
+  const result = getFormatters({ formatMonthCaption: () => "customMonth" });
+  expect(result.formatCaption(new Date(), {})).toBe("customMonth");
+  expect(result.formatMonthCaption(new Date(), {})).toBe("customMonth");
+});
+
+test("does not overwrite `formatCaption` if already defined", () => {
+  const result = getFormatters({
+    formatMonthCaption: () => "customMonth",
+    formatCaption: () => "customCaption"
+  });
+  expect(result.formatCaption(new Date(), {})).toBe("customCaption");
+  expect(result.formatMonthCaption(new Date(), {})).toBe("customMonth");
+});
+
+test("assigns `formatYearCaption` to `formatYearDropdown` if `formatYearDropdown` is not defined", () => {
+  const result = getFormatters({ formatYearCaption: () => "customYear" });
+  expect(result.formatYearDropdown(new Date(2000, 0))).toBe("customYear");
+  expect(result.formatYearCaption(new Date(2000, 0))).toBe("customYear");
+});
+
+test("does not overwrite `formatYearDropdown` if already defined", () => {
+  const result = getFormatters({
+    formatYearCaption: () => "customYear",
+    formatYearDropdown: () => "customDropdown"
+  });
+  expect(result.formatYearDropdown(new Date())).toBe("customDropdown");
+  expect(result.formatYearCaption(new Date())).toBe("customYear");
+});

package/src/helpers/getFormatters.ts

@@ -0,0 +1,19 @@
+import * as defaultFormatters from "../formatters/index.js";
+import type { DayPickerProps } from "../types/index.js";
+
+/** Return the formatters from the props merged with the default formatters. */
+export function getFormatters(customFormatters: DayPickerProps["formatters"]) {
+  if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) {
+    customFormatters.formatCaption = customFormatters.formatMonthCaption;
+  }
+  if (
+    customFormatters?.formatYearCaption &&
+    !customFormatters.formatYearDropdown
+  ) {
+    customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
+  }
+  return {
+    ...defaultFormatters,
+    ...customFormatters
+  };
+}

package/src/helpers/getInitialMonth.test.ts

@@ -0,0 +1,79 @@
+import { addMonths, isSameDay, isSameMonth, startOfMonth } from "date-fns";
+
+import { defaultDateLib } from "../classes/DateLib";
+
+import { getInitialMonth } from "./getInitialMonth";
+
+it("return start of month", () => {
+  const month = new Date(2010, 11, 12);
+  const initialMonth = getInitialMonth({ month }, defaultDateLib);
+  expect(isSameDay(initialMonth, startOfMonth(month))).toBe(true);
+});
+
+describe("when no startMonth or endMonth is given", () => {
+  const month = new Date(2010, 11, 12);
+  const defaultMonth = new Date(2011, 11, 12);
+  const today = new Date(2012, 11, 12);
+  describe("when month is in context", () => {
+    it("return that month", () => {
+      const initialMonth = getInitialMonth(
+        { month, defaultMonth, today },
+        defaultDateLib
+      );
+      expect(isSameMonth(initialMonth, month)).toBe(true);
+    });
+  });
+  describe("when defaultMonth is in context and no month is given", () => {
+    it("return that month", () => {
+      const initialMonth = getInitialMonth(
+        { defaultMonth, today },
+        defaultDateLib
+      );
+      expect(isSameMonth(initialMonth, defaultMonth)).toBe(true);
+    });
+  });
+  describe("when no month or defaultMonth", () => {
+    it("return the today month", () => {
+      const initialMonth = getInitialMonth({ today }, defaultDateLib);
+      expect(isSameMonth(initialMonth, today)).toBe(true);
+    });
+  });
+});
+
+describe("when startMonth is given and is after the default initial month", () => {
+  it("return the startMonth", () => {
+    const month = new Date(2010, 11, 12);
+    const startMonth = addMonths(month, 1);
+    const initialMonth = getInitialMonth(
+      { month, numberOfMonths: 3, startMonth },
+      defaultDateLib
+    );
+    expect(isSameMonth(initialMonth, startMonth)).toBe(true);
+  });
+});
+
+describe("when endMonth is given", () => {
+  describe("when endMonth is before the default initial month", () => {
+    const month = new Date(2010, 11, 12);
+    const endMonth = addMonths(month, -2);
+    describe("when the number of month is 1", () => {
+      it("return the endMonth", () => {
+        const initialMonth = getInitialMonth(
+          { month, endMonth },
+          defaultDateLib
+        );
+        expect(isSameMonth(initialMonth, endMonth)).toBe(true);
+      });
+    });
+    describe("when the number of month is 3", () => {
+      it("return the endMonth plus the number of months", () => {
+        const initialMonth = getInitialMonth(
+          { month, numberOfMonths: 3, endMonth },
+          defaultDateLib
+        );
+        const expectedMonth = addMonths(endMonth, -1 * (3 - 1));
+        expect(isSameMonth(initialMonth, expectedMonth)).toBe(true);
+      });
+    });
+  });
+});

package/src/helpers/getInitialMonth.ts

@@ -0,0 +1,41 @@
+import { type DateLib } from "../classes/DateLib.js";
+import { type DayPickerProps } from "../types/props.js";
+
+/** Return the start month based on the props passed to DayPicker. */
+export function getInitialMonth(
+  props: Pick<
+    DayPickerProps,
+    | "fromYear"
+    | "toYear"
+    | "startMonth"
+    | "endMonth"
+    | "month"
+    | "defaultMonth"
+    | "today"
+    | "numberOfMonths"
+    | "timeZone"
+  >,
+  dateLib: DateLib
+): Date {
+  const {
+    month,
+    defaultMonth,
+    today = dateLib.today(),
+    numberOfMonths = 1,
+    endMonth,
+    startMonth
+  } = props;
+  let initialMonth = month || defaultMonth || today;
+  const { differenceInCalendarMonths, addMonths, startOfMonth } = dateLib;
+
+  // Fix the initialMonth if is after the endMonth
+  if (endMonth && differenceInCalendarMonths(endMonth, initialMonth) < 0) {
+    const offset = -1 * (numberOfMonths - 1);
+    initialMonth = addMonths(endMonth, offset);
+  }
+  // Fix the initialMonth if is before the startMonth
+  if (startMonth && differenceInCalendarMonths(initialMonth, startMonth) < 0) {
+    initialMonth = startMonth;
+  }
+  return startOfMonth(initialMonth);
+}

package/src/helpers/getLabels.ts

@@ -0,0 +1,10 @@
+import * as defaultLabels from "../labels/index.js";
+import type { DayPickerProps, Labels } from "../types/index.js";
+
+/** Return the formatters from the props merged with the default formatters. */
+export function getLabels(customLabels: DayPickerProps["labels"]): Labels {
+  return {
+    ...defaultLabels,
+    ...customLabels
+  };
+}

package/src/helpers/getMonthOptions.test.ts

@@ -0,0 +1,226 @@
+import { defaultDateLib } from "../classes/DateLib";
+import * as formatters from "../formatters/index.js";
+
+import { getMonthOptions } from "./getMonthOptions";
+
+describe("return correct dropdown options", () => {
+  test("when navStart and navEnd are defined", () => {
+    const displayMonth = new Date(2022, 0, 1);
+    const startMonth = new Date(2022, 0, 1);
+    const endMonth = new Date(2022, 11, 31);
+    const result = getMonthOptions(
+      displayMonth,
+      startMonth,
+      endMonth,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: false },
+      { value: 1, label: "February", disabled: false },
+      { value: 2, label: "March", disabled: false },
+      { value: 3, label: "April", disabled: false },
+      { value: 4, label: "May", disabled: false },
+      { value: 5, label: "June", disabled: false },
+      { value: 6, label: "July", disabled: false },
+      { value: 7, label: "August", disabled: false },
+      { value: 8, label: "September", disabled: false },
+      { value: 9, label: "October", disabled: false },
+      { value: 10, label: "November", disabled: false },
+      { value: 11, label: "December", disabled: false }
+    ]);
+  });
+
+  test("when navStart and navEnd are undefined", () => {
+    const displayMonth = new Date(2022, 0, 1);
+    const result = getMonthOptions(
+      displayMonth,
+      undefined,
+      undefined,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: false },
+      { value: 1, label: "February", disabled: false },
+      { value: 2, label: "March", disabled: false },
+      { value: 3, label: "April", disabled: false },
+      { value: 4, label: "May", disabled: false },
+      { value: 5, label: "June", disabled: false },
+      { value: 6, label: "July", disabled: false },
+      { value: 7, label: "August", disabled: false },
+      { value: 8, label: "September", disabled: false },
+      { value: 9, label: "October", disabled: false },
+      { value: 10, label: "November", disabled: false },
+      { value: 11, label: "December", disabled: false }
+    ]);
+  });
+
+  test("when less than 12 months between start and end month", () => {
+    const displayMonth = new Date(2024, 9);
+    const startMonth = new Date(2024, 9);
+    const endMonth = new Date(2025, 5);
+    const result = getMonthOptions(
+      displayMonth,
+      startMonth,
+      endMonth,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: true },
+      { value: 1, label: "February", disabled: true },
+      { value: 2, label: "March", disabled: true },
+      { value: 3, label: "April", disabled: true },
+      { value: 4, label: "May", disabled: true },
+      { value: 5, label: "June", disabled: true },
+      { value: 6, label: "July", disabled: true },
+      { value: 7, label: "August", disabled: true },
+      { value: 8, label: "September", disabled: true },
+      { value: 9, label: "October", disabled: false },
+      { value: 10, label: "November", disabled: false },
+      { value: 11, label: "December", disabled: false }
+    ]);
+  });
+
+  test("return undefined when navStart is undefined", () => {
+    const displayMonth = new Date(2022, 0, 1);
+    const endMonth = new Date(2022, 6, 31);
+    const result = getMonthOptions(
+      displayMonth,
+      undefined,
+      endMonth,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: false },
+      { value: 1, label: "February", disabled: false },
+      { value: 2, label: "March", disabled: false },
+      { value: 3, label: "April", disabled: false },
+      { value: 4, label: "May", disabled: false },
+      { value: 5, label: "June", disabled: false },
+      { value: 6, label: "July", disabled: false },
+      { value: 7, label: "August", disabled: true },
+      { value: 8, label: "September", disabled: true },
+      { value: 9, label: "October", disabled: true },
+      { value: 10, label: "November", disabled: true },
+      { value: 11, label: "December", disabled: true }
+    ]);
+  });
+
+  test("return undefined when navEnd is undefined", () => {
+    const displayMonth = new Date(2022, 6, 1);
+    const startMonth = new Date(2022, 3, 1);
+    const result = getMonthOptions(
+      displayMonth,
+      startMonth,
+      undefined,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: true },
+      { value: 1, label: "February", disabled: true },
+      { value: 2, label: "March", disabled: true },
+      { value: 3, label: "April", disabled: false },
+      { value: 4, label: "May", disabled: false },
+      { value: 5, label: "June", disabled: false },
+      { value: 6, label: "July", disabled: false },
+      { value: 7, label: "August", disabled: false },
+      { value: 8, label: "September", disabled: false },
+      { value: 9, label: "October", disabled: false },
+      { value: 10, label: "November", disabled: false },
+      { value: 11, label: "December", disabled: false }
+    ]);
+  });
+
+  test("when navStart is after displayMonth", () => {
+    const displayMonth = new Date(2022, 0, 1);
+    const startMonth = new Date(2022, 2, 1);
+    const endMonth = new Date(2022, 11, 31);
+    const result = getMonthOptions(
+      displayMonth,
+      startMonth,
+      endMonth,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: true },
+      { value: 1, label: "February", disabled: true },
+      { value: 2, label: "March", disabled: false },
+      { value: 3, label: "April", disabled: false },
+      { value: 4, label: "May", disabled: false },
+      { value: 5, label: "June", disabled: false },
+      { value: 6, label: "July", disabled: false },
+      { value: 7, label: "August", disabled: false },
+      { value: 8, label: "September", disabled: false },
+      { value: 9, label: "October", disabled: false },
+      { value: 10, label: "November", disabled: false },
+      { value: 11, label: "December", disabled: false }
+    ]);
+  });
+
+  test("when navEnd is before displayMonth", () => {
+    const displayMonth = new Date(2022, 6, 1);
+    const startMonth = new Date(2022, 0, 1);
+    const endMonth = new Date(2022, 5, 30);
+    const result = getMonthOptions(
+      displayMonth,
+      startMonth,
+      endMonth,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: false },
+      { value: 1, label: "February", disabled: false },
+      { value: 2, label: "March", disabled: false },
+      { value: 3, label: "April", disabled: false },
+      { value: 4, label: "May", disabled: false },
+      { value: 5, label: "June", disabled: false },
+      { value: 6, label: "July", disabled: true },
+      { value: 7, label: "August", disabled: true },
+      { value: 8, label: "September", disabled: true },
+      { value: 9, label: "October", disabled: true },
+      { value: 10, label: "November", disabled: true },
+      { value: 11, label: "December", disabled: true }
+    ]);
+  });
+
+  test("when navStart and navEnd are within the same year", () => {
+    const displayMonth = new Date(2022, 0, 1);
+    const startMonth = new Date(2022, 2, 1);
+    const endMonth = new Date(2022, 8, 30);
+    const result = getMonthOptions(
+      displayMonth,
+      startMonth,
+      endMonth,
+      formatters,
+      defaultDateLib
+    );
+
+    expect(result).toEqual([
+      { value: 0, label: "January", disabled: true },
+      { value: 1, label: "February", disabled: true },
+      { value: 2, label: "March", disabled: false },
+      { value: 3, label: "April", disabled: false },
+      { value: 4, label: "May", disabled: false },
+      { value: 5, label: "June", disabled: false },
+      { value: 6, label: "July", disabled: false },
+      { value: 7, label: "August", disabled: false },
+      { value: 8, label: "September", disabled: false },
+      { value: 9, label: "October", disabled: true },
+      { value: 10, label: "November", disabled: true },
+      { value: 11, label: "December", disabled: true }
+    ]);
+  });
+});