@opengovsg/oui 0.0.0-snapshot-20250320092749 → 0.0.0-snapshot-20250326084237

package/dist/cjs/range-calendar/range-calendar.cjs

@@ -0,0 +1,188 @@
+"use strict";
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var date = require('@internationalized/date');
+var reactAriaComponents = require('react-aria-components');
+var useDeepCompare = require('use-deep-compare');
+var ouiTheme = require('@opengovsg/oui-theme');
+var agnosticCalendarStateContext = require('../calendar/agnostic-calendar-state-context.cjs');
+var calendarBottomContent = require('../calendar/calendar-bottom-content.cjs');
+var calendarGridHeader = require('../calendar/calendar-grid-header.cjs');
+var calendarHeader = require('../calendar/calendar-header.cjs');
+var utils = require('../system/utils.cjs');
+var calendarStyleContext = require('../calendar/calendar-style-context.cjs');
+
+const RangeCalendar = react.forwardRef(function RangeCalendar2(originalProps, ref) {
+  const [props, variantProps] = utils.mapPropsVariants(
+    originalProps,
+    ouiTheme.calendarStyles.variantKeys
+  );
+  const {
+    className,
+    classNames,
+    weekdayStyle = "narrow",
+    minValue = new date.CalendarDate(1900, 0, 1),
+    maxValue = new date.CalendarDate(2100, 12, 31),
+    bottomContent,
+    showTodayButton = true,
+    errorMessage,
+    ...restProps
+  } = props;
+  const slots = useDeepCompare.useDeepCompareMemo(
+    () => ouiTheme.calendarStyles({ ...variantProps, isRange: true }),
+    [variantProps]
+  );
+  const context = react.useMemo(
+    () => ({
+      slots,
+      classNames,
+      className,
+      size: variantProps.size ?? ouiTheme.calendarStyles.defaultVariants.size
+    }),
+    [className, classNames, slots, variantProps.size]
+  );
+  const numberOfVisibleMonths = props.visibleDuration?.months ?? 1;
+  const dateToHighlight = react.useMemo(() => {
+    if (props.defaultFocusedValue !== void 0) {
+      return props.defaultFocusedValue;
+    }
+    return date.today(date.getLocalTimeZone());
+  }, [props.defaultFocusedValue]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactAriaComponents.RangeCalendar,
+    {
+      ...restProps,
+      ref,
+      minValue,
+      maxValue,
+      className: ouiTheme.composeRenderProps(
+        className,
+        (className2, renderProps) => slots.base({
+          className: ouiTheme.cn(classNames?.base, className2),
+          ...renderProps
+        })
+      ),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Provider, { values: [[calendarStyleContext.CalendarStyleContext, context]], children: /* @__PURE__ */ jsxRuntime.jsxs(RangeCalendarStateWrapper, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: slots.gridWrapper({
+                className: classNames?.gridWrapper
+              }),
+              children: Array.from({ length: numberOfVisibleMonths }).map((_, index) => /* @__PURE__ */ jsxRuntime.jsxs(
+                "div",
+                {
+                  className: slots.calendar({ className: classNames?.calendar }),
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(calendarHeader.CalendarHeader, { offsetMonths: index }),
+                    /* @__PURE__ */ jsxRuntime.jsxs(
+                      reactAriaComponents.CalendarGrid,
+                      {
+                        className: slots.grid({ className: classNames?.grid }),
+                        weekdayStyle,
+                        offset: { months: index },
+                        children: [
+                          /* @__PURE__ */ jsxRuntime.jsx(calendarGridHeader.CalendarGridHeader, {}),
+                          /* @__PURE__ */ jsxRuntime.jsx(
+                            reactAriaComponents.CalendarGridBody,
+                            {
+                              className: slots.gridBody({
+                                className: classNames?.gridBody
+                              }),
+                              children: (date) => /* @__PURE__ */ jsxRuntime.jsx(
+                                RangeCalendarCell,
+                                {
+                                  firstDayOfWeek: props.firstDayOfWeek,
+                                  dateToHighlight,
+                                  date,
+                                  isMultipleMonths: numberOfVisibleMonths >= 2
+                                }
+                              )
+                            }
+                          )
+                        ]
+                      }
+                    )
+                  ]
+                },
+                index
+              ))
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            calendarBottomContent.CalendarBottomContent,
+            {
+              bottomContent,
+              showTodayButton
+            }
+          )
+        ] }) }),
+        errorMessage && /* @__PURE__ */ jsxRuntime.jsx(
+          reactAriaComponents.Text,
+          {
+            className: slots.errorMessage({
+              className: classNames?.errorMessage
+            }),
+            slot: "errorMessage",
+            children: errorMessage
+          }
+        )
+      ]
+    }
+  );
+});
+const RangeCalendarStateWrapper = ({
+  children
+}) => {
+  const state = react.useContext(reactAriaComponents.RangeCalendarStateContext);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Provider, { values: [[agnosticCalendarStateContext.AgnosticCalendarStateContext, state]], children });
+};
+const RangeCalendarCell = ({
+  date: date$1,
+  isMultipleMonths,
+  dateToHighlight,
+  firstDayOfWeek
+}) => {
+  const { classNames, slots } = calendarStyleContext.useCalendarStyleContext();
+  const state = react.useContext(agnosticCalendarStateContext.AgnosticCalendarStateContext);
+  const { locale } = reactAriaComponents.useLocale();
+  const dataAttributes = react.useMemo(() => {
+    const isDateHighlighted = dateToHighlight ? date$1.compare(dateToHighlight) === 0 : false;
+    const isSelected = state.isSelected(date$1);
+    const isDisabled = state.isCellDisabled(date$1);
+    const isInvalid = state.isInvalid(date$1);
+    const isFirstSelectedAfterDisabled = !isDisabled && !isInvalid && state.isCellUnavailable(date$1.subtract({ days: 1 }));
+    const isLastSelectedBeforeDisabled = !isDisabled && !isInvalid && state.isCellUnavailable(date$1.add({ days: 1 }));
+    const dayOfWeek = date.getDayOfWeek(date$1, locale, firstDayOfWeek);
+    const isRangeStart = isSelected && (isFirstSelectedAfterDisabled || dayOfWeek === 0 || date$1.day === 1);
+    const isRangeEnd = isSelected && (isLastSelectedBeforeDisabled || dayOfWeek === 6 || date$1.day === date$1.calendar.getDaysInMonth(date$1));
+    return {
+      "data-highlighted": ouiTheme.dataAttr(isDateHighlighted),
+      "data-range-end": ouiTheme.dataAttr(isRangeEnd),
+      "data-range-start": ouiTheme.dataAttr(isRangeStart)
+    };
+  }, [date$1, dateToHighlight, firstDayOfWeek, locale, state]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactAriaComponents.CalendarCell,
+    {
+      className: ouiTheme.composeRenderProps(
+        classNames?.cell,
+        (className, renderProps) => slots.cell({
+          className,
+          isMultipleMonths,
+          ...renderProps
+        })
+      ),
+      ...dataAttributes,
+      date: date$1
+    }
+  );
+};
+
+exports.RangeCalendar = RangeCalendar;
+exports.RangeCalendarCell = RangeCalendarCell;
+exports.RangeCalendarStateWrapper = RangeCalendarStateWrapper;

package/dist/esm/calendar/agnostic-calendar-state-context.js

@@ -0,0 +1,10 @@
+"use strict";
+"use client";
+import { createContext } from '../system/react-utils/context.js';
+
+const [AgnosticCalendarStateContext, useAgnosticCalendarStateContext] = createContext({
+  name: "AgnosticCalendarStateContext",
+  strict: true
+});
+
+export { AgnosticCalendarStateContext, useAgnosticCalendarStateContext };

package/dist/esm/calendar/calendar-bottom-content.js

@@ -0,0 +1,49 @@
+"use strict";
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useContext } from 'react';
+import { today, getLocalTimeZone } from '@internationalized/date';
+import { Button } from '../button/button.js';
+import { AgnosticCalendarStateContext } from './agnostic-calendar-state-context.js';
+import { useCalendarStyleContext } from './calendar-style-context.js';
+import { useCalendarI18n } from './hooks/use-calendar-i18n.js';
+
+const CalendarBottomContent = ({
+  bottomContent,
+  showTodayButton
+}) => {
+  const state = useContext(AgnosticCalendarStateContext);
+  const { slots, classNames, size } = useCalendarStyleContext();
+  const formatMessage = useCalendarI18n();
+  if (bottomContent) {
+    return bottomContent;
+  }
+  if (!showTodayButton) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: slots.bottomContentWrapper({
+        className: classNames?.bottomContentWrapper
+      }),
+      children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          isDisabled: state.isDisabled,
+          variant: "clear",
+          color: "sub",
+          size,
+          slot: null,
+          className: slots.todayButton({ className: classNames?.todayButton }),
+          onPress: () => {
+            state.setFocusedDate(today(getLocalTimeZone()));
+          },
+          children: formatMessage("today")
+        }
+      )
+    }
+  );
+};
+
+export { CalendarBottomContent };

package/dist/esm/calendar/calendar-grid-header.js

@@ -0,0 +1,26 @@
+"use strict";
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { CalendarGridHeader as CalendarGridHeader$1, CalendarHeaderCell } from 'react-aria-components';
+import { useCalendarStyleContext } from './calendar-style-context.js';
+
+function CalendarGridHeader() {
+  const { slots, classNames } = useCalendarStyleContext();
+  return /* @__PURE__ */ jsx(
+    CalendarGridHeader$1,
+    {
+      className: slots.gridHeader({ className: classNames?.gridHeader }),
+      children: (day) => /* @__PURE__ */ jsx(
+        CalendarHeaderCell,
+        {
+          className: slots.gridHeaderCell({
+            className: classNames?.gridHeaderCell
+          }),
+          children: day
+        }
+      )
+    }
+  );
+}
+
+export { CalendarGridHeader };

package/dist/esm/calendar/calendar-header.js

@@ -0,0 +1,72 @@
+"use strict";
+"use client";
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useContext } from 'react';
+import { useLocale, Group, Heading } from 'react-aria-components';
+import { Button } from '../button/button.js';
+import { AgnosticCalendarStateContext } from './agnostic-calendar-state-context.js';
+import { CalendarMonthDaySelector } from './calendar-month-day-selector.js';
+import { useCalendarStyleContext } from './calendar-style-context.js';
+import { useLocalizedMonthYear } from './utils.js';
+import ChevronRight from '../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevron-right.js';
+import ChevronLeft from '../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevron-left.js';
+
+function CalendarHeader({ offsetMonths = 0 }) {
+  const { direction } = useLocale();
+  const { slots, classNames, size } = useCalendarStyleContext();
+  const state = useContext(AgnosticCalendarStateContext);
+  const monthYearTitle = useLocalizedMonthYear(
+    state.visibleRange.start.add({ months: offsetMonths }),
+    state.timeZone
+  );
+  if (offsetMonths === 0) {
+    return /* @__PURE__ */ jsxs("div", { className: slots.header({ className: classNames?.header }), children: [
+      /* @__PURE__ */ jsx(CalendarMonthDaySelector, {}),
+      /* @__PURE__ */ jsxs(
+        Group,
+        {
+          className: slots.buttonGroup({ className: classNames?.buttonGroup }),
+          children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size,
+                isIconOnly: true,
+                variant: "clear",
+                color: "sub",
+                slot: "previous",
+                className: slots.prevButton({ className: classNames?.prevButton }),
+                children: direction === "rtl" ? /* @__PURE__ */ jsx(ChevronRight, { "aria-hidden": true }) : /* @__PURE__ */ jsx(ChevronLeft, { "aria-hidden": true })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size,
+                variant: "clear",
+                color: "sub",
+                isIconOnly: true,
+                slot: "next",
+                className: slots.nextButton({
+                  className: classNames?.nextButton
+                }),
+                children: direction === "rtl" ? /* @__PURE__ */ jsx(ChevronLeft, { "aria-hidden": true }) : /* @__PURE__ */ jsx(ChevronRight, { "aria-hidden": true })
+              }
+            )
+          ]
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsx(
+    Heading,
+    {
+      className: slots.header({ className: classNames?.header }),
+      "aria-hidden": true,
+      level: 2,
+      children: monthYearTitle
+    }
+  );
+}
+
+export { CalendarHeader };

package/dist/esm/calendar/calendar-month-day-selector.js

@@ -0,0 +1,84 @@
+"use strict";
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useContext } from 'react';
+import { CalendarDate } from '@internationalized/date';
+import { Group } from 'react-aria-components';
+import { AgnosticCalendarStateContext } from './agnostic-calendar-state-context.js';
+import { useCalendarStyleContext } from './calendar-style-context.js';
+import { useCalendarSelectors } from './hooks/use-calendar-selectors.js';
+import { Select } from '../select/select.js';
+import { SelectItem } from '../select/select-item.js';
+import { useCalendarI18n } from './hooks/use-calendar-i18n.js';
+
+const CalendarMonthDaySelector = () => {
+  const { slots, size, classNames } = useCalendarStyleContext();
+  const state = useContext(AgnosticCalendarStateContext);
+  const { months, years, datePartOrder } = useCalendarSelectors(state);
+  const formatMessage = useCalendarI18n();
+  return /* @__PURE__ */ jsx(Group, { className: slots.selectors({ className: classNames?.selectors }), children: datePartOrder.map((part) => {
+    if (part === "month") {
+      return /* @__PURE__ */ jsx(
+        Select,
+        {
+          isDisabled: state.isDisabled,
+          size,
+          items: months,
+          variant: "clear",
+          classNames: {
+            trigger: slots.monthSelector({
+              className: classNames?.monthSelector
+            }),
+            list: slots.monthList({ className: classNames?.monthList }),
+            selectedText: slots.selectorText({
+              className: classNames?.selectorText
+            }),
+            popover: "min-w-[12ch]"
+          },
+          selectedKey: state.visibleRange.start.month,
+          "aria-label": formatMessage("selectMonth"),
+          onSelectionChange: (month) => {
+            state.setFocusedDate(
+              new CalendarDate(state.focusedDate.year, Number(month), 1)
+            );
+          },
+          children: (month) => /* @__PURE__ */ jsx(SelectItem, { children: month.textValue })
+        },
+        part
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      Select,
+      {
+        isDisabled: state.isDisabled,
+        size,
+        variant: "clear",
+        items: years,
+        classNames: {
+          trigger: slots.yearSelector({
+            className: classNames?.yearSelector
+          }),
+          list: slots.yearList({ className: classNames?.yearList }),
+          selectedText: slots.selectorText({
+            className: classNames?.selectorText
+          })
+        },
+        selectedKey: state.visibleRange.start.year,
+        "aria-label": formatMessage("selectYear"),
+        onSelectionChange: (year) => {
+          state.setFocusedDate(
+            new CalendarDate(
+              Number(year),
+              state.focusedDate.month,
+              state.focusedDate.day
+            )
+          );
+        },
+        children: (year) => /* @__PURE__ */ jsx(SelectItem, { children: year.textValue })
+      },
+      part
+    );
+  }) });
+};
+
+export { CalendarMonthDaySelector };

package/dist/esm/calendar/calendar-style-context.js

@@ -1,34 +1,10 @@
 "use strict";
 "use client";
-import { useDeepCompareMemo } from 'use-deep-compare';
-import { calendarStyles } from '@opengovsg/oui-theme';
-import { mapPropsVariants } from '../system/utils.js';
 import { createContext } from '../system/react-utils/context.js';
 
-function useProvideCalendarStyles(originalProps) {
-  const [props, variantProps] = mapPropsVariants(
-    originalProps,
-    calendarStyles.variantKeys
-  );
-  const { errorMessage, className, classNames, ...restProps } = props;
-  const slots = useDeepCompareMemo(
-    () => calendarStyles(variantProps),
-    [variantProps]
-  );
-  return {
-    context: {
-      slots,
-      classNames,
-      className,
-      size: variantProps.size ?? calendarStyles.defaultVariants.size,
-      errorMessage
-    },
-    calendarProps: { ...restProps, onChange: restProps.onChange }
-  };
-}
 const [CalendarStyleContext, useCalendarStyleContext] = createContext({
   name: "CalendarStyleContext",
   strict: true
 });
 
-export { CalendarStyleContext, useCalendarStyleContext, useProvideCalendarStyles };
+export { CalendarStyleContext, useCalendarStyleContext };

package/dist/esm/calendar/calendar.js

@@ -1,14 +1,152 @@
 "use strict";
 "use client";
-import { jsx } from 'react/jsx-runtime';
-import { Provider } from 'react-aria-components';
-import { forwardRef } from '../system/utils.js';
-import { CalendarBase } from './calendar-base.js';
-import { useProvideCalendarStyles, CalendarStyleContext } from './calendar-style-context.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useMemo, useContext } from 'react';
+import { CalendarDate, today, getLocalTimeZone } from '@internationalized/date';
+import { Calendar as Calendar$1, composeRenderProps, Provider, CalendarGrid, CalendarGridBody, CalendarCell, Text, CalendarStateContext } from 'react-aria-components';
+import { useDeepCompareMemo } from 'use-deep-compare';
+import { calendarStyles, dataAttr, cn } from '@opengovsg/oui-theme';
+import { forwardRef, mapPropsVariants } from '../system/utils.js';
+import { AgnosticCalendarStateContext } from './agnostic-calendar-state-context.js';
+import { CalendarBottomContent } from './calendar-bottom-content.js';
+import { CalendarGridHeader } from './calendar-grid-header.js';
+import { CalendarHeader } from './calendar-header.js';
+import { CalendarStyleContext } from './calendar-style-context.js';
 
-const Calendar = forwardRef(function Calendar2(props, ref) {
-  const { calendarProps, context } = useProvideCalendarStyles(props);
-  return /* @__PURE__ */ jsx(Provider, { values: [[CalendarStyleContext, context]], children: /* @__PURE__ */ jsx(CalendarBase, { calendarRef: ref, ...calendarProps }) });
+const Calendar = forwardRef(function Calendar2(originalProps, ref) {
+  const [props, variantProps] = mapPropsVariants(
+    originalProps,
+    calendarStyles.variantKeys
+  );
+  const {
+    className,
+    classNames,
+    weekdayStyle = "narrow",
+    minValue = new CalendarDate(1900, 0, 1),
+    maxValue = new CalendarDate(2100, 12, 31),
+    bottomContent,
+    showTodayButton = true,
+    errorMessage,
+    ...restProps
+  } = props;
+  const slots = useDeepCompareMemo(
+    () => calendarStyles(variantProps),
+    [variantProps]
+  );
+  const context = useMemo(
+    () => ({
+      slots,
+      classNames,
+      className,
+      size: variantProps.size ?? calendarStyles.defaultVariants.size
+    }),
+    [className, classNames, slots, variantProps.size]
+  );
+  const numberOfVisibleMonths = props.visibleDuration?.months ?? 1;
+  const dateToHighlight = useMemo(() => {
+    if (props.defaultFocusedValue !== void 0) {
+      return props.defaultFocusedValue;
+    }
+    return today(getLocalTimeZone());
+  }, [props.defaultFocusedValue]);
+  return /* @__PURE__ */ jsxs(
+    Calendar$1,
+    {
+      pageBehavior: "single",
+      ...restProps,
+      ref,
+      minValue,
+      maxValue,
+      className: composeRenderProps(
+        className,
+        (className2, renderProps) => slots.base({
+          className: cn(classNames?.base, className2),
+          ...renderProps
+        })
+      ),
+      children: [
+        /* @__PURE__ */ jsx(CalendarStateWrapper, { children: /* @__PURE__ */ jsxs(Provider, { values: [[CalendarStyleContext, context]], children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: slots.gridWrapper({
+                className: classNames?.gridWrapper
+              }),
+              children: Array.from({ length: numberOfVisibleMonths }).map((_, index) => /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  className: slots.calendar({ className: classNames?.calendar }),
+                  children: [
+                    /* @__PURE__ */ jsx(CalendarHeader, { offsetMonths: index }),
+                    /* @__PURE__ */ jsxs(
+                      CalendarGrid,
+                      {
+                        className: slots.grid({ className: classNames?.grid }),
+                        weekdayStyle,
+                        offset: { months: index },
+                        children: [
+                          /* @__PURE__ */ jsx(CalendarGridHeader, {}),
+                          /* @__PURE__ */ jsx(
+                            CalendarGridBody,
+                            {
+                              className: slots.gridBody({
+                                className: classNames?.gridBody
+                              }),
+                              children: (date) => /* @__PURE__ */ jsx(
+                                CalendarCell,
+                                {
+                                  className: composeRenderProps(
+                                    classNames?.cell,
+                                    (className2, renderProps) => slots.cell({
+                                      className: className2,
+                                      isMultipleMonths: numberOfVisibleMonths >= 2,
+                                      ...renderProps
+                                    })
+                                  ),
+                                  "data-highlighted": dataAttr(
+                                    dateToHighlight ? date.compare(dateToHighlight) === 0 : false
+                                  ),
+                                  date
+                                }
+                              )
+                            }
+                          )
+                        ]
+                      }
+                    )
+                  ]
+                },
+                index
+              ))
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            CalendarBottomContent,
+            {
+              bottomContent,
+              showTodayButton
+            }
+          )
+        ] }) }),
+        errorMessage && /* @__PURE__ */ jsx(
+          Text,
+          {
+            className: slots.errorMessage({
+              className: classNames?.errorMessage
+            }),
+            slot: "errorMessage",
+            children: errorMessage
+          }
+        )
+      ]
+    }
+  );
 });
+const CalendarStateWrapper = ({
+  children
+}) => {
+  const state = useContext(CalendarStateContext);
+  return /* @__PURE__ */ jsx(Provider, { values: [[AgnosticCalendarStateContext, state]], children });
+};
 
-export { Calendar };
+export { Calendar, CalendarStateWrapper };

package/dist/esm/calendar/hooks/index.js

@@ -0,0 +1,3 @@
+"use strict";
+export { i18nStrings, useCalendarI18n } from './use-calendar-i18n.js';
+export { useCalendarSelectors } from './use-calendar-selectors.js';

package/dist/esm/calendar/hooks/use-calendar-i18n.js

@@ -0,0 +1,30 @@
+"use strict";
+import { useMessageFormatter } from 'react-aria';
+
+const i18nStrings = {
+  "en-SG": {
+    selectMonth: "Select month",
+    selectYear: "Select year",
+    today: "Today"
+  },
+  "zh-SG": {
+    selectMonth: "\u9009\u62E9\u6708\u4EFD",
+    selectYear: "\u9009\u62E9\u5E74\u4EFD",
+    today: "\u4ECA\u5929"
+  },
+  "ms-SG": {
+    selectMonth: "Pilih bulan",
+    selectYear: "Pilih tahun",
+    today: "Hari ini"
+  },
+  "ta-SG": {
+    selectMonth: "\u0BAE\u0BBE\u0BA4\u0BA4\u0BCD\u0BA4\u0BC8 \u0BA4\u0BC7\u0BB0\u0BCD\u0BA8\u0BCD\u0BA4\u0BC6\u0B9F\u0BC1\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD",
+    selectYear: "\u0B86\u0BA3\u0BCD\u0B9F\u0BC8 \u0BA4\u0BC7\u0BB0\u0BCD\u0BA8\u0BCD\u0BA4\u0BC6\u0B9F\u0BC1\u0B95\u0BCD\u0B95\u0BB5\u0BC1\u0BAE\u0BCD",
+    today: "\u0B87\u0BA9\u0BCD\u0BB1\u0BC1"
+  }
+};
+const useCalendarI18n = () => {
+  return useMessageFormatter(i18nStrings);
+};
+
+export { i18nStrings, useCalendarI18n };