@opengovsg/oui 0.0.0-snapshot-20251103063040 → 0.0.0-snapshot-20251203091804

package/dist/cjs/file-dropzone/file-dropzone.cjs

@@ -0,0 +1,311 @@
+"use strict";
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var form = require('@react-stately/form');
+var reactAria = require('react-aria');
+var reactAriaComponents = require('react-aria-components');
+var reactDropzone = require('react-dropzone');
+var ouiTheme = require('@opengovsg/oui-theme');
+var field = require('../field/field.cjs');
+var useControllableState = require('../hooks/use-controllable-state.cjs');
+var utils = require('../system/utils.cjs');
+var contexts = require('./contexts.cjs');
+var fileInfo = require('./file-info.cjs');
+var utils$1 = require('./utils.cjs');
+var upload = require('../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/upload.cjs');
+
+const FileDropzone = (originalProps) => {
+  const [props, variantProps] = utils.mapPropsVariants(
+    originalProps,
+    ouiTheme.fileDropzoneStyles.variantKeys
+  );
+  const {
+    name,
+    allowedMimeTypes = [],
+    maxFileSize = Number.POSITIVE_INFINITY,
+    minFileSize = 0,
+    showFileSizeText = true,
+    maxFiles = 1,
+    isDisabled,
+    isReadOnly,
+    classNames,
+    itemClassNames,
+    validator,
+    showRejectedFiles,
+    onError,
+    errorMessage,
+    label,
+    description,
+    children,
+    hideDropzoneOnValue = maxFiles === 1,
+    imagePreview = "small"
+  } = props;
+  const [value, setValue] = useControllableState.useControllableState({
+    value: props.value,
+    defaultValue: props.defaultValue || [],
+    onChange: props.onChange
+  });
+  const [rejections, setRejections] = useControllableState.useControllableState({
+    value: props.rejections,
+    defaultValue: [],
+    onChange: props.onRejection
+  });
+  const validationState = form.useFormValidationState({
+    ...props,
+    value
+  });
+  const { isInvalid, validationErrors, validationDetails } = validationState.displayValidation;
+  const { labelProps, fieldProps, descriptionProps, errorMessageProps } = reactAria.useField({
+    ...props,
+    isInvalid,
+    errorMessage: props.errorMessage || validationErrors
+  });
+  const slots = ouiTheme.fileDropzoneStyles(variantProps);
+  const fileSizeTextId = reactAria.useId();
+  const formatError = react.useCallback(
+    (error) => utils$1.formatErrorMessage(error, {
+      maxFileSize,
+      minFileSize,
+      maxFiles
+    }),
+    [maxFileSize, maxFiles, minFileSize]
+  );
+  const onDrop = react.useCallback(
+    (acceptedFiles, fileRejections) => {
+      const files = acceptedFiles;
+      if (showRejectedFiles) {
+        const invalidFiles = fileRejections.map(({ file, errors }) => {
+          file.errors = errors;
+          return file;
+        });
+        setRejections(invalidFiles);
+      }
+      setValue(files);
+      if (onError && fileRejections.length > 0) {
+        const firstError = fileRejections[0].errors[0];
+        onError(formatError(firstError));
+      }
+    },
+    [formatError, onError, setRejections, setValue, showRejectedFiles]
+  );
+  const handleRemoveFile = react.useCallback(
+    (fileName) => {
+      setValue((files) => files.filter((file) => file.name !== fileName));
+    },
+    [setValue]
+  );
+  const handleRemoveRejection = react.useCallback(
+    (fileName) => {
+      setRejections(
+        (rejections2) => rejections2.filter((file) => file.name !== fileName)
+      );
+    },
+    [setRejections]
+  );
+  const { getInputProps, ...dropzoneState } = reactDropzone.useDropzone({
+    validator,
+    accept: allowedMimeTypes.reduce(
+      (acc, type) => ({ ...acc, [type]: [] }),
+      {}
+    ),
+    onError: (e) => onError?.(e.message),
+    onDrop,
+    disabled: isDisabled,
+    noDrag: isReadOnly,
+    // Prevent ref hijack when there is a label
+    noClick: true,
+    noKeyboard: true,
+    maxSize: maxFileSize,
+    minSize: minFileSize,
+    maxFiles,
+    multiple: maxFiles !== 1
+  });
+  const fileSizeText = react.useMemo(() => {
+    const notDefaultMaxFileSize = maxFileSize !== Number.POSITIVE_INFINITY;
+    const notDefaultMinFileSize = minFileSize !== 0;
+    const shouldShow = showFileSizeText && (notDefaultMaxFileSize || notDefaultMinFileSize);
+    if (!shouldShow) return null;
+    if (notDefaultMaxFileSize && notDefaultMinFileSize) {
+      return `File size must be between ${utils$1.formatBytes(minFileSize, 2)} and ${utils$1.formatBytes(
+        maxFileSize,
+        2
+      )}`;
+    }
+    if (notDefaultMaxFileSize) {
+      return `Maximum file size: ${utils$1.formatBytes(maxFileSize, 2)}`;
+    }
+    if (notDefaultMinFileSize) {
+      return `Minimum file size: ${utils$1.formatBytes(minFileSize, 2)}`;
+    }
+    return null;
+  }, [maxFileSize, minFileSize, showFileSizeText]);
+  const triggerFileSelector = react.useCallback(() => {
+    if (isDisabled || isReadOnly) return;
+    dropzoneState.inputRef.current?.click();
+  }, [dropzoneState, isDisabled, isReadOnly]);
+  react.useEffect(() => {
+    if (value.length <= maxFiles) {
+      let changed = false;
+      const newFiles = value.map((file) => {
+        if (file.errors?.some((e) => e.code === "too-many-files")) {
+          file.errors = file.errors.filter((e) => e.code !== "too-many-files");
+          changed = true;
+        }
+        return file;
+      });
+      if (changed) {
+        setValue(newFiles);
+      }
+    }
+  }, [maxFiles, setValue, value]);
+  const inputProps = react.useMemo(() => {
+    const inputProps2 = { ...fieldProps, name };
+    if (fileSizeText) {
+      inputProps2["aria-describedby"] = inputProps2["aria-describedby"] ? `${inputProps2["aria-describedby"]} ${fileSizeTextId}` : fileSizeTextId;
+    }
+    return getInputProps(inputProps2);
+  }, [fieldProps, getInputProps, fileSizeTextId, name, fileSizeText]);
+  const showDropzone = react.useMemo(() => {
+    if (hideDropzoneOnValue) {
+      return value.length < maxFiles;
+    }
+    return true;
+  }, [hideDropzoneOnValue, maxFiles, value.length]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactAriaComponents.Provider,
+    {
+      values: [
+        [
+          contexts.FileDropzoneStyleContext,
+          { slots, classNames, itemClassNames, ...variantProps }
+        ],
+        [
+          contexts.FileDropzoneStateContext,
+          {
+            isDisabled,
+            isReadOnly,
+            maxFiles,
+            maxFileSize,
+            showDropzone,
+            files: value,
+            handleRemoveFile,
+            handleRemoveRejection,
+            formatError,
+            inputProps,
+            triggerFileSelector,
+            ...dropzoneState
+          }
+        ],
+        [reactAriaComponents.LabelContext, labelProps],
+        [
+          reactAriaComponents.GroupContext,
+          {
+            role: "presentation",
+            isInvalid,
+            isDisabled: props.isDisabled || false
+          }
+        ],
+        [
+          reactAriaComponents.TextContext,
+          {
+            slots: {
+              fileSize: {},
+              description: descriptionProps,
+              errorMessage: errorMessageProps
+            }
+          }
+        ],
+        [reactAriaComponents.FieldErrorContext, { isInvalid, validationErrors, validationDetails }]
+      ],
+      children: /* @__PURE__ */ jsxRuntime.jsxs(reactAriaComponents.Group, { className: slots.base({ className: classNames?.base }), children: [
+        label && /* @__PURE__ */ jsxRuntime.jsx(field.Label, { size: variantProps.size, children: label }),
+        showDropzone && /* @__PURE__ */ jsxRuntime.jsx(FileDropzoneDropzone, {}),
+        value.map((file) => {
+          if (typeof children === "function") {
+            return children({
+              file,
+              removeFile: () => handleRemoveFile(file.name)
+            });
+          }
+          return /* @__PURE__ */ jsxRuntime.jsx(fileInfo.FileInfo, { imagePreview, file }, file.name);
+        }),
+        rejections.length >= 1 && rejections.map((rj) => /* @__PURE__ */ jsxRuntime.jsx(fileInfo.FileInfo, { imagePreview, file: rj }, rj.name)),
+        fileSizeText && /* @__PURE__ */ jsxRuntime.jsx(
+          field.Description,
+          {
+            size: variantProps.size,
+            id: fileSizeTextId,
+            slot: "fileSize",
+            children: fileSizeText
+          }
+        ),
+        description && /* @__PURE__ */ jsxRuntime.jsx(field.Description, { size: variantProps.size, children: description }),
+        errorMessage && /* @__PURE__ */ jsxRuntime.jsx(field.FieldError, { size: variantProps.size, children: errorMessage })
+      ] })
+    }
+  );
+};
+const FileDropzoneDropzone = () => {
+  const {
+    maxFiles,
+    getRootProps,
+    inputProps,
+    triggerFileSelector,
+    isDisabled,
+    isDragActive
+  } = contexts.useFileDropzoneStateContext();
+  const { slots, classNames } = contexts.useFileDropzoneStyleContext();
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ...getRootProps({
+        "aria-disabled": isDisabled,
+        className: slots.group({
+          className: classNames?.group
+        })
+      }),
+      tabIndex: isDisabled ? void 0 : 0,
+      onClick: triggerFileSelector,
+      onKeyDown: (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          triggerFileSelector();
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("input", { ...inputProps }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            "data-dragging": ouiTheme.dataAttr(isDragActive),
+            className: slots.dropzone({ className: classNames?.dropzone }),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(upload.default, { className: slots.icon({ className: classNames?.icon }) }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: slots.text({ className: classNames?.text }), children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(
+                  "span",
+                  {
+                    className: slots.dropzoneHighlight({
+                      className: classNames?.dropzoneHighlight
+                    }),
+                    children: [
+                      "Choose ",
+                      maxFiles === 1 ? `file` : `files`
+                    ]
+                  }
+                ),
+                " ",
+                "or drag and drop here"
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+
+exports.FileDropzone = FileDropzone;

package/dist/cjs/file-dropzone/file-info.cjs

@@ -0,0 +1,146 @@
+"use strict";
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var ouiTheme = require('@opengovsg/oui-theme');
+var button = require('../button/button.cjs');
+var contexts = require('./contexts.cjs');
+var utils = require('./utils.cjs');
+var trash2 = require('../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/trash-2.cjs');
+
+const FileInfo = ({ file, imagePreview, classNames }) => {
+  const {
+    handleRemoveFile,
+    handleRemoveRejection,
+    formatError,
+    isDisabled,
+    isReadOnly
+  } = contexts.useFileDropzoneStateContext();
+  const { size, variant, itemClassNames } = contexts.useFileDropzoneStyleContext();
+  const readableFileSize = utils.formatBytes(file.size, 2);
+  const styles = ouiTheme.fileInfoDropzoneStyles({
+    size,
+    variant,
+    imagePreview: imagePreview ?? void 0
+  });
+  const [previewSrc, setPreviewSrc] = react.useState("");
+  react.useEffect(() => {
+    let objectUrl = "";
+    if (file.type.startsWith("image/")) {
+      objectUrl = URL.createObjectURL(file);
+      setPreviewSrc(objectUrl);
+    }
+    return () => URL.revokeObjectURL(objectUrl);
+  }, [file]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: styles.base({
+        className: ouiTheme.cn(itemClassNames?.base, classNames?.base)
+      }),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sr-only", children: [
+          "File attached: ",
+          file.name,
+          " with file size of ",
+          readableFileSize
+        ] }),
+        imagePreview && previewSrc && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: styles.imageContainer({
+              className: ouiTheme.cn(
+                itemClassNames?.imageContainer,
+                classNames?.imageContainer
+              )
+            }),
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "img",
+              {
+                src: previewSrc,
+                alt: `Image preview of uploaded file: ${file.name}`,
+                className: styles.image({
+                  className: ouiTheme.cn(itemClassNames?.image, classNames?.image)
+                })
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: styles.container({
+              className: ouiTheme.cn(itemClassNames?.container, classNames?.container)
+            }),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(
+                "div",
+                {
+                  className: styles.textContainer({
+                    className: ouiTheme.cn(
+                      itemClassNames?.textContainer,
+                      classNames?.textContainer
+                    )
+                  }),
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      "p",
+                      {
+                        title: file.name,
+                        className: styles.name({
+                          className: ouiTheme.cn(itemClassNames?.name, classNames?.name)
+                        }),
+                        children: file.name
+                      }
+                    ),
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      "p",
+                      {
+                        className: styles.size({
+                          className: ouiTheme.cn(itemClassNames?.size, classNames?.size)
+                        }),
+                        children: readableFileSize
+                      }
+                    ),
+                    file.errors?.length && /* @__PURE__ */ jsxRuntime.jsx(
+                      "p",
+                      {
+                        className: styles.error({
+                          className: ouiTheme.cn(itemClassNames?.error, classNames?.error)
+                        }),
+                        children: file.errors.map(formatError).join(", ")
+                      }
+                    )
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                button.Button,
+                {
+                  isDisabled: isDisabled || isReadOnly,
+                  isIconOnly: !file.errors?.length,
+                  size: size === "md" ? "md" : "xs",
+                  variant: "clear",
+                  color: file.errors?.length ? "main" : "critical",
+                  "aria-label": "Remove file",
+                  className: styles.actionButton({
+                    className: ouiTheme.cn(
+                      itemClassNames?.actionButton,
+                      classNames?.actionButton
+                    )
+                  }),
+                  onPress: () => file.errors?.length ? handleRemoveRejection(file.name) : handleRemoveFile(file.name),
+                  children: file.errors?.length ? "Dismiss" : /* @__PURE__ */ jsxRuntime.jsx(trash2.default, {})
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+
+exports.FileInfo = FileInfo;

package/dist/cjs/file-dropzone/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+'use strict';
+
+var fileDropzone = require('./file-dropzone.cjs');
+var fileInfo = require('./file-info.cjs');
+var utils = require('./utils.cjs');
+
+
+
+exports.FileDropzone = fileDropzone.FileDropzone;
+exports.FileInfo = fileInfo.FileInfo;
+exports.formatBytes = utils.formatBytes;
+exports.formatErrorMessage = utils.formatErrorMessage;

package/dist/cjs/file-dropzone/types.cjs

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

package/dist/cjs/file-dropzone/utils.cjs

@@ -0,0 +1,31 @@
+"use strict";
+'use strict';
+
+var reactDropzone = require('react-dropzone');
+
+const formatBytes = (bytes, decimals = 2, size) => {
+  const k = 1e3;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  if (bytes === 0 || bytes === void 0)
+    return size !== void 0 ? `0 ${size}` : "0 bytes";
+  const i = size !== void 0 ? sizes.indexOf(size) : Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+};
+const formatErrorMessage = (error, config) => {
+  const { maxFileSize, minFileSize, maxFiles } = config;
+  switch (error.code) {
+    case reactDropzone.ErrorCode.FileTooLarge:
+      return `You have exceeded the size limit, please upload a file below ${formatBytes(maxFileSize, 2)}`;
+    case reactDropzone.ErrorCode.FileTooSmall:
+      return `Please upload a file above ${formatBytes(minFileSize, 2)}`;
+    case reactDropzone.ErrorCode.TooManyFiles:
+      return `Maximum number of files allowed is ${maxFiles}.`;
+    default: {
+      return error.message;
+    }
+  }
+};
+
+exports.formatBytes = formatBytes;
+exports.formatErrorMessage = formatErrorMessage;

package/dist/cjs/govt-banner/govt-banner.cjs

@@ -3,7 +3,7 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var $670gB$react = require('react');
+var react = require('react');
 var reactAria = require('react-aria');
 var reactStately = require('react-stately');
 var ouiTheme = require('@opengovsg/oui-theme');
@@ -18,8 +18,8 @@ function GovtBanner({
   ...props
 }) {
   const state = reactStately.useDisclosureState(props);
-  const panelRef = $670gB$react.useRef(null);
-  const triggerRef = $670gB$react.useRef(null);
+  const panelRef = react.useRef(null);
+  const triggerRef = react.useRef(null);
   const { buttonProps: triggerProps, panelProps } = reactAria.useDisclosure(
     props,
     state,

package/dist/cjs/hooks/index.cjs

@@ -2,7 +2,9 @@
 'use strict';
 
 var useControllableState = require('./use-controllable-state.cjs');
+var useDraggable = require('./use-draggable.cjs');
 
 
 
 exports.useControllableState = useControllableState.useControllableState;
+exports.useDraggable = useDraggable.useDraggable;

package/dist/cjs/hooks/use-callback-ref.cjs

@@ -2,16 +2,16 @@
 "use client";
 'use strict';
 
-var $670gB$react = require('react');
+var react = require('react');
 
 function useCallbackRef(callback, deps = []) {
-  const callbackRef = $670gB$react.useRef(() => {
+  const callbackRef = react.useRef(() => {
     throw new Error("Cannot call an event handler while rendering.");
   });
-  $670gB$react.useInsertionEffect(() => {
+  react.useInsertionEffect(() => {
     callbackRef.current = callback;
   });
-  return $670gB$react.useCallback((...args) => callbackRef.current?.(...args), deps);
+  return react.useCallback((...args) => callbackRef.current?.(...args), deps);
 }
 
 exports.useCallbackRef = useCallbackRef;

package/dist/cjs/hooks/use-controllable-state.cjs

@@ -2,7 +2,7 @@
 "use client";
 'use strict';
 
-var $670gB$react = require('react');
+var react = require('react');
 var useCallbackRef = require('./use-callback-ref.cjs');
 
 function useControllableState(props) {
@@ -14,7 +14,7 @@ function useControllableState(props) {
   } = props;
   const onChangeProp = useCallbackRef.useCallbackRef(onChange);
   const shouldUpdateProp = useCallbackRef.useCallbackRef(shouldUpdate);
-  const [uncontrolledState, setUncontrolledState] = $670gB$react.useState(defaultValue);
+  const [uncontrolledState, setUncontrolledState] = react.useState(defaultValue);
   const controlled = valueProp !== void 0;
   const value = controlled ? valueProp : uncontrolledState;
   const setValue = useCallbackRef.useCallbackRef(

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

@@ -0,0 +1,88 @@
+"use strict";
+"use client";
+'use strict';
+
+var react = require('react');
+var interactions = require('@react-aria/interactions');
+
+function useDraggable(props) {
+  const { targetRef, isDisabled = false, canOverflow = false } = props;
+  const boundary = react.useRef({ minLeft: 0, minTop: 0, maxLeft: 0, maxTop: 0 });
+  const isDragging = react.useRef(false);
+  let transform = { offsetX: 0, offsetY: 0 };
+  const onMoveStart = react.useCallback(() => {
+    isDragging.current = true;
+    const { offsetX, offsetY } = transform;
+    const targetRect = targetRef?.current?.getBoundingClientRect();
+    const targetLeft = targetRect?.left ?? 0;
+    const targetTop = targetRect?.top ?? 0;
+    const targetWidth = targetRect?.width ?? 0;
+    const targetHeight = targetRect?.height ?? 0;
+    const clientWidth = document.documentElement.clientWidth;
+    const clientHeight = document.documentElement.clientHeight;
+    const minLeft = -targetLeft + offsetX;
+    const minTop = -targetTop + offsetY;
+    const maxLeft = clientWidth - targetLeft - targetWidth + offsetX;
+    const maxTop = clientHeight - targetTop - targetHeight + offsetY;
+    boundary.current = {
+      minLeft,
+      minTop,
+      maxLeft,
+      maxTop
+    };
+  }, [transform, targetRef?.current]);
+  const onMove = react.useCallback(
+    (e) => {
+      if (isDisabled) {
+        return;
+      }
+      const { offsetX, offsetY } = transform;
+      const { minLeft, minTop, maxLeft, maxTop } = boundary.current;
+      let moveX = offsetX + e.deltaX;
+      let moveY = offsetY + e.deltaY;
+      if (!canOverflow) {
+        moveX = Math.min(Math.max(moveX, minLeft), maxLeft);
+        moveY = Math.min(Math.max(moveY, minTop), maxTop);
+      }
+      transform = {
+        offsetX: moveX,
+        offsetY: moveY
+      };
+      if (targetRef?.current) {
+        targetRef.current.style.transform = `translate(${moveX}px, ${moveY}px)`;
+      }
+    },
+    [isDisabled, transform, boundary.current, canOverflow, targetRef?.current]
+  );
+  const onMoveEnd = react.useCallback(() => {
+    isDragging.current = false;
+  }, []);
+  const { moveProps } = interactions.useMove({
+    onMoveStart,
+    onMove,
+    onMoveEnd
+  });
+  const preventDefault = react.useCallback((e) => {
+    if (isDragging.current) {
+      e.preventDefault();
+    }
+  }, []);
+  react.useEffect(() => {
+    if (!isDisabled) {
+      document.body.addEventListener("touchmove", preventDefault, {
+        passive: false
+      });
+    }
+    return () => {
+      document.body.removeEventListener("touchmove", preventDefault);
+    };
+  }, [isDisabled, preventDefault]);
+  return {
+    moveProps: {
+      ...moveProps,
+      style: { cursor: !isDisabled ? "move" : void 0 }
+    }
+  };
+}
+
+exports.useDraggable = useDraggable;