@opengovsg/oui 0.0.7 → 0.0.9

package/dist/cjs/badge/badge.cjs

@@ -0,0 +1,42 @@
+"use strict";
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var useBadge = require('./use-badge.cjs');
+var x = require('../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/x.cjs');
+
+const Badge = react.forwardRef((props, ref) => {
+  const {
+    Component,
+    children,
+    slots,
+    classNames,
+    getChipProps,
+    getCloseButtonProps,
+    startContent,
+    endContent,
+    isCloseable
+  } = useBadge.useBadge({ ...props, ref });
+  const start = react.useMemo(() => {
+    if (props.variant === "dot" && !startContent) {
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: slots.dot({ className: classNames?.dot }) });
+    }
+    return startContent;
+  }, [props.variant, startContent, slots, classNames?.dot]);
+  const end = react.useMemo(() => {
+    if (isCloseable) {
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { ...getCloseButtonProps(), children: endContent ?? /* @__PURE__ */ jsxRuntime.jsx(x.default, { className: "size-full" }) });
+    }
+    return endContent;
+  }, [endContent, getCloseButtonProps, isCloseable]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(Component, { ...getChipProps(), children: [
+    start,
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: slots.content({ className: classNames?.content }), children }),
+    end
+  ] });
+});
+Badge.displayName = "Badge";
+
+exports.Badge = Badge;

package/dist/cjs/badge/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+'use strict';
+
+var badge = require('./badge.cjs');
+
+
+
+exports.Badge = badge.Badge;

package/dist/cjs/badge/use-badge.cjs

@@ -0,0 +1,111 @@
+"use strict";
+'use strict';
+
+var react = require('react');
+var utils$1 = require('@react-aria/utils');
+var reactAria = require('react-aria');
+var useDeepCompare = require('use-deep-compare');
+var ouiTheme = require('@opengovsg/oui-theme');
+var utils = require('../system/utils.cjs');
+var refs = require('../system/react-utils/refs.cjs');
+
+const i18nStrings = {
+  "en-SG": {
+    close: "Close badge"
+  },
+  "zh-SG": {
+    close: "\u5173\u95ED\u5FBD\u7AE0"
+  },
+  "ms-SG": {
+    close: "Tutup lencana"
+  },
+  "ta-SG": {
+    close: "\u0BAA\u0BC7\u0B9F\u0BCD\u0B9C\u0BC8 \u0BAE\u0BC2\u0B9F\u0BC1"
+  }
+};
+function useBadge(originalProps) {
+  const [_props, variantProps] = utils.mapPropsVariants(
+    originalProps,
+    ouiTheme.badgeStyles.variantKeys
+  );
+  const {
+    ref,
+    as,
+    children,
+    startContent,
+    endContent,
+    onClose,
+    classNames,
+    className,
+    ...props
+  } = _props;
+  const domRef = refs.useDomRef(ref);
+  const Component = react.useMemo(() => as || "div", [as]);
+  const baseClassName = ouiTheme.cn(classNames?.base, className);
+  const formatMessage = reactAria.useMessageFormatter(i18nStrings);
+  const isCloseable = variantProps.isCloseable || !!onClose;
+  const {
+    focusProps: closeFocusProps,
+    isFocusVisible: isCloseButtonFocusVisible
+  } = reactAria.useFocusRing();
+  const slots = useDeepCompare.useDeepCompareMemo(
+    () => ({
+      ...ouiTheme.badgeStyles({ isCloseable, ...variantProps }),
+      closeButton: ouiTheme.badgeCloseButtonStyles
+    }),
+    [variantProps, isCloseable, ouiTheme.badgeStyles, ouiTheme.badgeCloseButtonStyles]
+  );
+  const { pressProps: closePressProps } = reactAria.usePress({
+    isDisabled: !!variantProps?.isDisabled,
+    onPress: onClose
+  });
+  const getContentClone = react.useCallback(
+    (content) => react.isValidElement(content) ? react.cloneElement(content, {
+      // @ts-expect-error types are not full
+      className: content.props?.className
+    }) : null,
+    []
+  );
+  const getChipProps = react.useCallback(() => {
+    return {
+      ref: domRef,
+      className: slots.base({ className: baseClassName }),
+      "aria-disabled": variantProps?.isDisabled,
+      ...props
+    };
+  }, [baseClassName, domRef, props, slots, variantProps?.isDisabled]);
+  const getCloseButtonProps = react.useCallback(() => {
+    return {
+      role: "button",
+      tabIndex: 0,
+      className: slots.closeButton({
+        size: variantProps?.size,
+        className: classNames?.closeButton,
+        isFocusVisible: isCloseButtonFocusVisible
+      }),
+      "aria-label": formatMessage("close"),
+      ...utils$1.mergeProps(closePressProps, closeFocusProps)
+    };
+  }, [
+    classNames?.closeButton,
+    closeFocusProps,
+    closePressProps,
+    formatMessage,
+    isCloseButtonFocusVisible,
+    slots,
+    variantProps?.size
+  ]);
+  return {
+    Component,
+    children,
+    slots,
+    classNames,
+    isCloseable,
+    startContent: getContentClone(startContent),
+    endContent: getContentClone(endContent),
+    getCloseButtonProps,
+    getChipProps
+  };
+}
+
+exports.useBadge = useBadge;

package/dist/cjs/calendar/calendar-base.cjs

@@ -0,0 +1,347 @@
+"use strict";
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var date = require('@internationalized/date');
+var reactAria = require('react-aria');
+var reactAriaComponents = require('react-aria-components');
+var ouiTheme = require('@opengovsg/oui-theme');
+var button = require('../button/button.cjs');
+var calendarStyleContext = require('./calendar-style-context.cjs');
+var utils = require('./utils.cjs');
+var chevronRight = require('../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevron-right.cjs');
+var chevronLeft = require('../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevron-left.cjs');
+var select = require('../select/select.cjs');
+var selectItem = require('../select/select-item.cjs');
+
+const useCalendarSelectors = (state) => {
+  const yearRange = react.useMemo(() => {
+    const start = state.minValue.year ?? 1900;
+    const end = state.maxValue.year ?? 2100;
+    return { start, end };
+  }, [state.maxValue, state.minValue]);
+  const dateFormatter = reactAria.useDateFormatter(state);
+  const datePartOrder = react.useMemo(() => {
+    const parts = dateFormatter.formatToParts(
+      state.visibleRange.start.toDate(state.timeZone)
+    );
+    const filteredParts = parts.filter(
+      (part) => ["year", "month"].includes(part.type)
+    );
+    const filteredPartNames = filteredParts.map((part) => part.type);
+    return filteredPartNames;
+  }, [dateFormatter, state.timeZone, state.visibleRange.start]);
+  const months = utils.useGenerateLocalizedMonths(state.timeZone);
+  const years = utils.useGenerateLocalizedYears(
+    yearRange.start,
+    yearRange.end,
+    state.timeZone
+  );
+  return react.useMemo(() => {
+    return {
+      months,
+      years,
+      datePartOrder
+    };
+  }, [datePartOrder, months, years]);
+};
+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 CalendarBottomContent = ({
+  bottomContent,
+  showTodayButton
+}) => {
+  const state = react.useContext(reactAriaComponents.CalendarStateContext);
+  const { slots, classNames, size } = calendarStyleContext.useCalendarStyleContext();
+  const formatMessage = reactAria.useMessageFormatter(i18nStrings);
+  if (bottomContent) {
+    return bottomContent;
+  }
+  if (!showTodayButton) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: slots.bottomContentWrapper({
+        className: classNames?.bottomContentWrapper
+      }),
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        button.Button,
+        {
+          isDisabled: state.isDisabled,
+          variant: "clear",
+          color: "sub",
+          size,
+          slot: null,
+          className: slots.todayButton({ className: classNames?.todayButton }),
+          onPress: () => {
+            state.setFocusedDate(date.today(date.getLocalTimeZone()));
+          },
+          children: formatMessage("today")
+        }
+      )
+    }
+  );
+};
+function CalendarBase({
+  weekdayStyle = "narrow",
+  calendarRef,
+  minValue = new date.CalendarDate(1900, 0, 1),
+  maxValue = new date.CalendarDate(2100, 12, 31),
+  bottomContent,
+  showTodayButton = true,
+  ...props
+}) {
+  const { slots, className, classNames } = calendarStyleContext.useCalendarStyleContext();
+  const numberOfVisibleMonths = props.visibleDuration?.months ?? 1;
+  const dateToHighlight = react.useMemo(() => {
+    return props.defaultFocusedValue ?? date.today(date.getLocalTimeZone());
+  }, [props.defaultFocusedValue]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactAriaComponents.Calendar,
+    {
+      pageBehavior: "single",
+      ...props,
+      ref: calendarRef,
+      minValue,
+      maxValue,
+      className: reactAriaComponents.composeRenderProps(
+        className,
+        (className2, renderProps) => slots.base({
+          className: ouiTheme.cn(classNames?.base, className2),
+          ...renderProps
+        })
+      ),
+      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, { offsetMonths: index }),
+                  /* @__PURE__ */ jsxRuntime.jsxs(
+                    reactAriaComponents.CalendarGrid,
+                    {
+                      className: slots.grid({ className: classNames?.grid }),
+                      weekdayStyle,
+                      offset: { months: index },
+                      children: [
+                        /* @__PURE__ */ jsxRuntime.jsx(CalendarGridHeader, {}),
+                        /* @__PURE__ */ jsxRuntime.jsx(
+                          reactAriaComponents.CalendarGridBody,
+                          {
+                            className: slots.gridBody({ className: classNames?.gridBody }),
+                            children: (date) => /* @__PURE__ */ jsxRuntime.jsx(
+                              reactAriaComponents.CalendarCell,
+                              {
+                                className: reactAriaComponents.composeRenderProps(
+                                  classNames?.cell,
+                                  (className2, renderProps) => slots.cell({
+                                    className: className2,
+                                    isMultipleMonths: numberOfVisibleMonths >= 2,
+                                    isDateHighlighted: date.compare(dateToHighlight) === 0,
+                                    ...renderProps
+                                  })
+                                ),
+                                date
+                              }
+                            )
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ]
+              },
+              index
+            ))
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          CalendarBottomContent,
+          {
+            bottomContent,
+            showTodayButton
+          }
+        )
+      ]
+    }
+  );
+}
+const CalendarMonthDaySelector = () => {
+  const { slots, size, classNames } = calendarStyleContext.useCalendarStyleContext();
+  const state = react.useContext(reactAriaComponents.CalendarStateContext);
+  const { months, years, datePartOrder } = useCalendarSelectors(state);
+  const formatMessage = reactAria.useMessageFormatter(i18nStrings);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Group, { className: slots.selectors({ className: classNames?.selectors }), children: datePartOrder.map((part) => {
+    if (part === "month") {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        select.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 date.CalendarDate(state.focusedDate.year, Number(month), 1)
+            );
+          },
+          children: (month) => /* @__PURE__ */ jsxRuntime.jsx(selectItem.SelectItem, { children: month.textValue })
+        },
+        part
+      );
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      select.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 date.CalendarDate(
+              Number(year),
+              state.focusedDate.month,
+              state.focusedDate.day
+            )
+          );
+        },
+        children: (year) => /* @__PURE__ */ jsxRuntime.jsx(selectItem.SelectItem, { children: year.textValue })
+      },
+      part
+    );
+  }) });
+};
+function CalendarHeader({ offsetMonths = 0 }) {
+  const { direction } = reactAriaComponents.useLocale();
+  const { slots, classNames, size } = calendarStyleContext.useCalendarStyleContext();
+  const state = react.useContext(reactAriaComponents.CalendarStateContext);
+  const monthYearTitle = utils.useLocalizedMonthYear(
+    state.visibleRange.start.add({ months: offsetMonths }),
+    state.timeZone
+  );
+  if (offsetMonths === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: slots.header({ className: classNames?.header }), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(CalendarMonthDaySelector, {}),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        reactAriaComponents.Group,
+        {
+          className: slots.buttonGroup({ className: classNames?.buttonGroup }),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              button.Button,
+              {
+                size,
+                isIconOnly: true,
+                variant: "clear",
+                color: "sub",
+                slot: "previous",
+                className: slots.prevButton({ className: classNames?.prevButton }),
+                children: direction === "rtl" ? /* @__PURE__ */ jsxRuntime.jsx(chevronRight.default, { "aria-hidden": true }) : /* @__PURE__ */ jsxRuntime.jsx(chevronLeft.default, { "aria-hidden": true })
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              button.Button,
+              {
+                size,
+                variant: "clear",
+                color: "sub",
+                isIconOnly: true,
+                slot: "next",
+                className: slots.nextButton({
+                  className: classNames?.nextButton
+                }),
+                children: direction === "rtl" ? /* @__PURE__ */ jsxRuntime.jsx(chevronLeft.default, { "aria-hidden": true }) : /* @__PURE__ */ jsxRuntime.jsx(chevronRight.default, { "aria-hidden": true })
+              }
+            )
+          ]
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactAriaComponents.Heading,
+    {
+      className: slots.header({ className: classNames?.header }),
+      "aria-hidden": true,
+      level: 2,
+      children: monthYearTitle
+    }
+  );
+}
+function CalendarGridHeader() {
+  const { slots, classNames } = calendarStyleContext.useCalendarStyleContext();
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactAriaComponents.CalendarGridHeader,
+    {
+      className: slots.gridHeader({ className: classNames?.gridHeader }),
+      children: (day) => /* @__PURE__ */ jsxRuntime.jsx(
+        reactAriaComponents.CalendarHeaderCell,
+        {
+          className: slots.gridHeaderCell({
+            className: classNames?.gridHeaderCell
+          }),
+          children: day
+        }
+      )
+    }
+  );
+}
+
+exports.CalendarBase = CalendarBase;
+exports.CalendarGridHeader = CalendarGridHeader;
+exports.CalendarHeader = CalendarHeader;

package/dist/cjs/calendar/calendar-style-context.cjs

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

package/dist/cjs/calendar/calendar.cjs

@@ -0,0 +1,16 @@
+"use strict";
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var reactAriaComponents = require('react-aria-components');
+var utils = require('../system/utils.cjs');
+var calendarBase = require('./calendar-base.cjs');
+var calendarStyleContext = require('./calendar-style-context.cjs');
+
+const Calendar = utils.forwardRef(function Calendar2(props, ref) {
+  const { calendarProps, context } = calendarStyleContext.useProvideCalendarStyles(props);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Provider, { values: [[calendarStyleContext.CalendarStyleContext, context]], children: /* @__PURE__ */ jsxRuntime.jsx(calendarBase.CalendarBase, { calendarRef: ref, ...calendarProps }) });
+});
+
+exports.Calendar = Calendar;

package/dist/cjs/calendar/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+'use strict';
+
+var calendar = require('./calendar.cjs');
+var calendarStyleContext = require('./calendar-style-context.cjs');
+var utils = require('./utils.cjs');
+var date = require('@internationalized/date');
+
+
+
+exports.Calendar = calendar.Calendar;
+exports.CalendarStyleContext = calendarStyleContext.CalendarStyleContext;
+exports.useCalendarStyleContext = calendarStyleContext.useCalendarStyleContext;
+exports.useProvideCalendarStyles = calendarStyleContext.useProvideCalendarStyles;
+exports.getEraFormat = utils.getEraFormat;
+exports.useGenerateLocalizedMonths = utils.useGenerateLocalizedMonths;
+exports.useGenerateLocalizedYears = utils.useGenerateLocalizedYears;
+exports.useLocalizedMonthYear = utils.useLocalizedMonthYear;
+Object.defineProperty(exports, "CalendarDate", {
+	enumerable: true,
+	get: function () { return date.CalendarDate; }
+});

package/dist/cjs/calendar/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+'use strict';
+

package/dist/cjs/calendar/utils.cjs

@@ -0,0 +1,62 @@
+"use strict";
+'use strict';
+
+var react = require('react');
+var date = require('@internationalized/date');
+var i18n = require('@react-aria/i18n');
+
+function getEraFormat(date) {
+  return date?.calendar.identifier === "gregory" && date.era === "BC" ? "short" : void 0;
+}
+function useLocalizedMonthYear(date, timeZone) {
+  const era = getEraFormat(date);
+  const monthFormatter = i18n.useDateFormatter({
+    month: "long",
+    year: "numeric",
+    era,
+    calendar: date.calendar.identifier,
+    timeZone
+  });
+  return monthFormatter.format(date.toDate(timeZone));
+}
+function useGenerateLocalizedMonths(timeZone, formatterOptions) {
+  const formatter = i18n.useDateFormatter({
+    month: "long",
+    timeZone,
+    ...formatterOptions
+  });
+  return react.useMemo(() => {
+    return Array.from({ length: 12 }, (_, i) => {
+      const id = i + 1;
+      return {
+        id,
+        textValue: formatter.format(
+          new date.CalendarDate(2020, id, 1).toDate(timeZone)
+        )
+      };
+    });
+  }, [formatter, timeZone]);
+}
+function useGenerateLocalizedYears(yearStart, yearEnd, timeZone, formatterOptions) {
+  const formatter = i18n.useDateFormatter({
+    year: "numeric",
+    timeZone,
+    ...formatterOptions
+  });
+  return react.useMemo(() => {
+    return Array.from({ length: yearEnd - yearStart + 1 }, (_, i) => {
+      const year = yearStart + i;
+      return {
+        id: year,
+        textValue: formatter.format(
+          new date.CalendarDate(year, 1, 1).toDate(timeZone)
+        )
+      };
+    });
+  }, [formatter, yearStart, yearEnd, timeZone]);
+}
+
+exports.getEraFormat = getEraFormat;
+exports.useGenerateLocalizedMonths = useGenerateLocalizedMonths;
+exports.useGenerateLocalizedYears = useGenerateLocalizedYears;
+exports.useLocalizedMonthYear = useLocalizedMonthYear;