@opengovsg/oui 0.0.0-snapshot-20250813090518 → 0.0.0-snapshot-20250813172831

package/dist/cjs/node_modules/.pnpm/@react-aria_interactions@3.25.3_react-dom@19.0.0_react@19.0.0__react@19.0.0/node_modules/@react-aria/interactions/dist/utils.cjs

@@ -0,0 +1,160 @@
+'use strict';
+
+var utils = require('@react-aria/utils');
+var $670gB$react = require('react');
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+function $8a9cb279dc87e130$export$525bc4921d56d4a(nativeEvent) {
+    let event = nativeEvent;
+    event.nativeEvent = nativeEvent;
+    event.isDefaultPrevented = ()=>event.defaultPrevented;
+    // cancelBubble is technically deprecated in the spec, but still supported in all browsers.
+    event.isPropagationStopped = ()=>event.cancelBubble;
+    event.persist = ()=>{};
+    return event;
+}
+function $8a9cb279dc87e130$export$c2b7abe5d61ec696(event, target) {
+    Object.defineProperty(event, 'target', {
+        value: target
+    });
+    Object.defineProperty(event, 'currentTarget', {
+        value: target
+    });
+}
+function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
+    let stateRef = ($670gB$react.useRef)({
+        isFocused: false,
+        observer: null
+    });
+    // Clean up MutationObserver on unmount. See below.
+    (utils.useLayoutEffect)(()=>{
+        const state = stateRef.current;
+        return ()=>{
+            if (state.observer) {
+                state.observer.disconnect();
+                state.observer = null;
+            }
+        };
+    }, []);
+    let dispatchBlur = (utils.useEffectEvent)((e)=>{
+        onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
+    });
+    // This function is called during a React onFocus event.
+    return ($670gB$react.useCallback)((e)=>{
+        // React does not fire onBlur when an element is disabled. https://github.com/facebook/react/issues/9142
+        // Most browsers fire a native focusout event in this case, except for Firefox. In that case, we use a
+        // MutationObserver to watch for the disabled attribute, and dispatch these events ourselves.
+        // For browsers that do, focusout fires before the MutationObserver, so onBlur should not fire twice.
+        if (e.target instanceof HTMLButtonElement || e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLSelectElement) {
+            stateRef.current.isFocused = true;
+            let target = e.target;
+            let onBlurHandler = (e)=>{
+                stateRef.current.isFocused = false;
+                if (target.disabled) {
+                    // For backward compatibility, dispatch a (fake) React synthetic event.
+                    let event = $8a9cb279dc87e130$export$525bc4921d56d4a(e);
+                    dispatchBlur(event);
+                }
+                // We no longer need the MutationObserver once the target is blurred.
+                if (stateRef.current.observer) {
+                    stateRef.current.observer.disconnect();
+                    stateRef.current.observer = null;
+                }
+            };
+            target.addEventListener('focusout', onBlurHandler, {
+                once: true
+            });
+            stateRef.current.observer = new MutationObserver(()=>{
+                if (stateRef.current.isFocused && target.disabled) {
+                    var _stateRef_current_observer;
+                    (_stateRef_current_observer = stateRef.current.observer) === null || _stateRef_current_observer === void 0 ? void 0 : _stateRef_current_observer.disconnect();
+                    let relatedTargetEl = target === document.activeElement ? null : document.activeElement;
+                    target.dispatchEvent(new FocusEvent('blur', {
+                        relatedTarget: relatedTargetEl
+                    }));
+                    target.dispatchEvent(new FocusEvent('focusout', {
+                        bubbles: true,
+                        relatedTarget: relatedTargetEl
+                    }));
+                }
+            });
+            stateRef.current.observer.observe(target, {
+                attributes: true,
+                attributeFilter: [
+                    'disabled'
+                ]
+            });
+        }
+    }, [
+        dispatchBlur
+    ]);
+}
+exports.ignoreFocusEvent = false;
+function $8a9cb279dc87e130$export$cabe61c495ee3649(target) {
+    // The browser will focus the nearest focusable ancestor of our target.
+    while(target && !(utils.isFocusable)(target))target = target.parentElement;
+    let window = (utils.getOwnerWindow)(target);
+    let activeElement = window.document.activeElement;
+    if (!activeElement || activeElement === target) return;
+    exports.ignoreFocusEvent = true;
+    let isRefocusing = false;
+    let onBlur = (e)=>{
+        if (e.target === activeElement || isRefocusing) e.stopImmediatePropagation();
+    };
+    let onFocusOut = (e)=>{
+        if (e.target === activeElement || isRefocusing) {
+            e.stopImmediatePropagation();
+            // If there was no focusable ancestor, we don't expect a focus event.
+            // Re-focus the original active element here.
+            if (!target && !isRefocusing) {
+                isRefocusing = true;
+                (utils.focusWithoutScrolling)(activeElement);
+                cleanup();
+            }
+        }
+    };
+    let onFocus = (e)=>{
+        if (e.target === target || isRefocusing) e.stopImmediatePropagation();
+    };
+    let onFocusIn = (e)=>{
+        if (e.target === target || isRefocusing) {
+            e.stopImmediatePropagation();
+            if (!isRefocusing) {
+                isRefocusing = true;
+                (utils.focusWithoutScrolling)(activeElement);
+                cleanup();
+            }
+        }
+    };
+    window.addEventListener('blur', onBlur, true);
+    window.addEventListener('focusout', onFocusOut, true);
+    window.addEventListener('focusin', onFocusIn, true);
+    window.addEventListener('focus', onFocus, true);
+    let cleanup = ()=>{
+        cancelAnimationFrame(raf);
+        window.removeEventListener('blur', onBlur, true);
+        window.removeEventListener('focusout', onFocusOut, true);
+        window.removeEventListener('focusin', onFocusIn, true);
+        window.removeEventListener('focus', onFocus, true);
+        exports.ignoreFocusEvent = false;
+        isRefocusing = false;
+    };
+    let raf = requestAnimationFrame(cleanup);
+    return cleanup;
+}
+
+exports.createSyntheticEvent = $8a9cb279dc87e130$export$525bc4921d56d4a;
+exports.preventFocus = $8a9cb279dc87e130$export$cabe61c495ee3649;
+exports.setEventTarget = $8a9cb279dc87e130$export$c2b7abe5d61ec696;
+exports.useSyntheticBlurEvent = $8a9cb279dc87e130$export$715c682d09d639cc;

package/dist/cjs/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_check_private_redeclaration.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+
+exports._ = _check_private_redeclaration;

package/dist/cjs/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_apply_descriptor_get.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+
+    return descriptor.value;
+}
+
+exports._ = _class_apply_descriptor_get;

package/dist/cjs/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_apply_descriptor_set.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) {
+            // This should only throw in strict mode, but class bodies are
+            // always strict and private fields can only be used inside
+            // class bodies.
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+
+exports._ = _class_apply_descriptor_set;

package/dist/cjs/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_extract_field_descriptor.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+
+    return privateMap.get(receiver);
+}
+
+exports._ = _class_extract_field_descriptor;

package/dist/cjs/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_private_field_get.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var _class_apply_descriptor_get = require('./_class_apply_descriptor_get.cjs');
+var _class_extract_field_descriptor = require('./_class_extract_field_descriptor.cjs');
+
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor._(receiver, privateMap, "get");
+    return _class_apply_descriptor_get._(receiver, descriptor);
+}
+
+exports._ = _class_private_field_get;

package/dist/cjs/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_private_field_init.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var _check_private_redeclaration = require('./_check_private_redeclaration.cjs');
+
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration._(obj, privateMap);
+    privateMap.set(obj, value);
+}
+
+exports._ = _class_private_field_init;

package/dist/cjs/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_private_field_set.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var _class_apply_descriptor_set = require('./_class_apply_descriptor_set.cjs');
+var _class_extract_field_descriptor = require('./_class_extract_field_descriptor.cjs');
+
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor._(receiver, privateMap, "set");
+    _class_apply_descriptor_set._(receiver, descriptor, value);
+    return value;
+}
+
+exports._ = _class_private_field_set;

package/dist/cjs/node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/Icon.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var react = require('react');
+var $670gB$react = require('react');
 var defaultAttributes = require('./defaultAttributes.cjs');
 var utils = require('./shared/src/utils.cjs');
 
@@ -14,7 +14,7 @@ var utils = require('./shared/src/utils.cjs');
  */
 
 
-const Icon = react.forwardRef(
+const Icon = $670gB$react.forwardRef(
   ({
     color = "currentColor",
     size = 24,
@@ -25,7 +25,7 @@ const Icon = react.forwardRef(
     iconNode,
     ...rest
   }, ref) => {
-    return react.createElement(
+    return $670gB$react.createElement(
       "svg",
       {
         ref,
@@ -38,7 +38,7 @@ const Icon = react.forwardRef(
         ...rest
       },
       [
-        ...iconNode.map(([tag, attrs]) => react.createElement(tag, attrs)),
+        ...iconNode.map(([tag, attrs]) => $670gB$react.createElement(tag, attrs)),
         ...Array.isArray(children) ? children : [children]
       ]
     );

package/dist/cjs/node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/createLucideIcon.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var react = require('react');
+var $670gB$react = require('react');
 var utils = require('./shared/src/utils.cjs');
 var Icon = require('./Icon.cjs');
 
@@ -15,8 +15,8 @@ var Icon = require('./Icon.cjs');
 
 
 const createLucideIcon = (iconName, iconNode) => {
-  const Component = react.forwardRef(
-    ({ className, ...props }, ref) => react.createElement(Icon.default, {
+  const Component = $670gB$react.forwardRef(
+    ({ className, ...props }, ref) => $670gB$react.createElement(Icon.default, {
       ref,
       iconNode,
       className: utils.mergeClasses(`lucide-${utils.toKebabCase(iconName)}`, className),

package/dist/cjs/node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevrons-right.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createLucideIcon = require('../createLucideIcon.cjs');
+
+/**
+ * @license lucide-react v0.475.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+
+const __iconNode = [
+  ["path", { d: "m6 17 5-5-5-5", key: "xnjwq" }],
+  ["path", { d: "m13 17 5-5-5-5", key: "17xmmf" }]
+];
+const ChevronsRight = createLucideIcon.default("ChevronsRight", __iconNode);
+
+exports.__iconNode = __iconNode;
+exports.default = ChevronsRight;

package/dist/cjs/node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/ellipsis.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createLucideIcon = require('../createLucideIcon.cjs');
+
+/**
+ * @license lucide-react v0.475.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+
+const __iconNode = [
+  ["circle", { cx: "12", cy: "12", r: "1", key: "41hilf" }],
+  ["circle", { cx: "19", cy: "12", r: "1", key: "1wjl8i" }],
+  ["circle", { cx: "5", cy: "12", r: "1", key: "1pcz8c" }]
+];
+const Ellipsis = createLucideIcon.default("Ellipsis", __iconNode);
+
+exports.__iconNode = __iconNode;
+exports.default = Ellipsis;

package/dist/cjs/pagination/hooks/use-pagination.cjs

@@ -0,0 +1,117 @@
+"use strict";
+"use client";
+'use strict';
+
+var $670gB$react = require('react');
+var i18n = require('@react-aria/i18n');
+
+var PaginationItemType = /* @__PURE__ */ ((PaginationItemType2) => {
+  PaginationItemType2["DOTS"] = "dots";
+  PaginationItemType2["PREV"] = "prev";
+  PaginationItemType2["NEXT"] = "next";
+  return PaginationItemType2;
+})(PaginationItemType || {});
+function range(start, end) {
+  const length = end - start + 1;
+  return Array.from({ length }, (_, index) => index + start);
+}
+function usePagination(props) {
+  const {
+    page,
+    total,
+    siblings = 1,
+    boundaries = 1,
+    initialPage = 1,
+    showControls = false,
+    onChange
+  } = props;
+  const [activePage, setActivePage] = $670gB$react.useState(page || initialPage);
+  const { direction } = i18n.useLocale();
+  const isRTL = direction === "rtl";
+  const onChangeActivePage = $670gB$react.useCallback(
+    (newPage) => {
+      setActivePage(newPage);
+      onChange?.(newPage);
+    },
+    [onChange]
+  );
+  $670gB$react.useEffect(() => {
+    if (page && page !== activePage) {
+      setActivePage(page);
+    }
+  }, [activePage, page]);
+  const setPage = $670gB$react.useCallback(
+    (pageNumber) => {
+      if (pageNumber <= 0) {
+        onChangeActivePage(1);
+      } else if (pageNumber > total) {
+        onChangeActivePage(total);
+      } else {
+        onChangeActivePage(pageNumber);
+      }
+    },
+    [total, onChangeActivePage]
+  );
+  const next = () => setPage(activePage + 1);
+  const previous = () => setPage(activePage - 1);
+  const first = () => setPage(1);
+  const last = () => setPage(total);
+  const formatRange = $670gB$react.useCallback(
+    (range2) => {
+      if (showControls) {
+        return ["prev" /* PREV */, ...range2, "next" /* NEXT */];
+      }
+      return range2;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [isRTL, showControls]
+  );
+  const paginationRange = $670gB$react.useMemo(() => {
+    const totalPageNumbers = siblings * 2 + 3 + boundaries * 2;
+    if (totalPageNumbers >= total) {
+      return formatRange(range(1, total));
+    }
+    const leftSiblingIndex = Math.max(activePage - siblings, boundaries);
+    const rightSiblingIndex = Math.min(
+      activePage + siblings,
+      total - boundaries
+    );
+    const shouldShowLeftDots = leftSiblingIndex > boundaries + 2;
+    const shouldShowRightDots = rightSiblingIndex < total - (boundaries + 1);
+    if (!shouldShowLeftDots && shouldShowRightDots) {
+      const leftItemCount = siblings * 2 + boundaries + 2;
+      return formatRange([
+        ...range(1, leftItemCount),
+        "dots" /* DOTS */,
+        ...range(total - (boundaries - 1), total)
+      ]);
+    }
+    if (shouldShowLeftDots && !shouldShowRightDots) {
+      const rightItemCount = boundaries + 1 + 2 * siblings;
+      return formatRange([
+        ...range(1, boundaries),
+        "dots" /* DOTS */,
+        ...range(total - rightItemCount, total)
+      ]);
+    }
+    return formatRange([
+      ...range(1, boundaries),
+      "dots" /* DOTS */,
+      ...range(leftSiblingIndex, rightSiblingIndex),
+      "dots" /* DOTS */,
+      ...range(total - boundaries + 1, total)
+    ]);
+  }, [total, activePage, siblings, boundaries, formatRange]);
+  return {
+    range: paginationRange,
+    activePage,
+    setPage,
+    next,
+    previous,
+    first,
+    last
+  };
+}
+
+exports.PaginationItemType = PaginationItemType;
+exports.usePagination = usePagination;

package/dist/cjs/pagination/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+'use strict';
+
+var pagination = require('./pagination.cjs');
+var paginationCursor = require('./pagination-cursor.cjs');
+var paginationItem = require('./pagination-item.cjs');
+var usePagination = require('./hooks/use-pagination.cjs');
+var usePagination$1 = require('./use-pagination.cjs');
+
+
+
+exports.Pagination = pagination.Pagination;
+exports.PaginationCursor = paginationCursor.PaginationCursor;
+exports.PaginationItem = paginationItem.PaginationItem;
+exports.PaginationItemType = usePagination.PaginationItemType;
+exports.CURSOR_TRANSITION_TIMEOUT = usePagination$1.CURSOR_TRANSITION_TIMEOUT;
+exports.usePagination = usePagination$1.usePagination;

package/dist/cjs/pagination/pagination-cursor.cjs

@@ -0,0 +1,18 @@
+"use strict";
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var utils = require('../system/utils.cjs');
+var refs = require('../system/react-utils/refs.cjs');
+
+const PaginationCursor = utils.forwardRef(
+  (props, ref) => {
+    const { as, activePage, ...otherProps } = props;
+    const Component = as || "span";
+    const domRef = refs.useDomRef(ref);
+    return /* @__PURE__ */ jsxRuntime.jsx(Component, { ref: domRef, "aria-hidden": true, ...otherProps, children: activePage });
+  }
+);
+
+exports.PaginationCursor = PaginationCursor;

package/dist/cjs/pagination/pagination-item.cjs

@@ -0,0 +1,18 @@
+"use strict";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var utils = require('../system/utils.cjs');
+var usePaginationItem = require('./use-pagination-item.cjs');
+
+const PaginationItem = utils.forwardRef(
+  (props, ref) => {
+    const { Component, children, getItemProps } = usePaginationItem.usePaginationItem({
+      ...props,
+      ref
+    });
+    return /* @__PURE__ */ jsxRuntime.jsx(Component, { ...getItemProps(), children });
+  }
+);
+
+exports.PaginationItem = PaginationItem;