repo_description: Simple HTML5 drag-drop zone with React.js.
repo_topics: drag-and-drop file file-upload react
code: /* eslint prefer-template: 0 */
  import React, {
    forwardRef,
    Fragment,
    useCallback,
    useEffect,
    useImperativeHandle,
    useMemo,
    useReducer,
    useRef,
  } from "react";
  import PropTypes from "prop-types";
  import { fromEvent } from "file-selector";
  import {
    acceptPropAsAcceptAttr,
    allFilesAccepted,
    composeEventHandlers,
    fileAccepted,
    fileMatchSize,
    canUseFileSystemAccessAPI,
    isAbort,
    isEvtWithFiles,
    isIeOrEdge,
    isPropagationStopped,
    isSecurityError,
    onDocumentDragOver,
    pickerOptionsFromAccept,
    TOO_MANY_FILES_REJECTION,
  } from "./utils/index.js";
  
  /**
   * Convenience wrapper component for the `useDropzone` hook
   *
   * ```jsx
   * <Dropzone>
   *   {({getRootProps, getInputProps}) => (
   *     <div {...getRootProps()}>
   *       <input {...getInputProps()} />
   *       <p>Drag 'n' drop some files here, or click to select files</p>
   *     </div>
   *   )}
   * </Dropzone>
   * ```
   */
  const Dropzone = forwardRef(({ children, ...params }, ref) => {
    const { open, ...props } = useDropzone(params);
  
    useImperativeHandle(ref, () => ({ open }), [open]);
  
    // TODO: Figure out why react-styleguidist cannot create docs if we don't return a jsx element
    return <Fragment>{children({ ...props, open })}</Fragment>;
  });
  
  Dropzone.displayName = "Dropzone";
  
  // Add default props for react-docgen
  const defaultProps = {
    disabled: false,
    getFilesFromEvent: fromEvent,
    maxSize: Infinity,
    minSize: 0,
    multiple: true,
    maxFiles: 0,
    preventDropOnDocument: true,
    noClick: false,
    noKeyboard: false,
    noDrag: false,
    noDragEventsBubbling: false,
    validator: null,
    useFsAccessApi: false,
    autoFocus: false,
  };
  
  Dropzone.defaultProps = defaultProps;
  
  Dropzone.propTypes = {
    /**
     * Render function that exposes the dropzone state and prop getter fns
     *
     * @param {object} params
     * @param {Function} params.getRootProps Returns the props you should apply to the root drop container you render
     * @param {Function} params.getInputProps Returns the props you should apply to hidden file input you render
     * @param {Function} params.open Open the native file selection dialog
     * @param {boolean} params.isFocused Dropzone area is in focus
     * @param {boolean} params.isFileDialogActive File dialog is opened
     * @param {boolean} params.isDragActive Active drag is in progress
     * @param {boolean} params.isDragAccept Dragged files are accepted
     * @param {boolean} params.isDragReject True only during an active drag when some dragged files would be rejected. After drop, this resets to false. Use fileRejections for post-drop errors.
     * @param {boolean} params.isDragGlobal Files are being dragged anywhere on the document
     * @param {File[]} params.acceptedFiles Accepted files
     * @param {FileRejection[]} params.fileRejections Rejected files and why they were rejected. This persists after drop and is the source of truth for post-drop rejections.
     */
    children: PropTypes.func,
  
    /**
     * Set accepted file types.
     * Checkout https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker types option for more information.
     * Keep in mind that mime type determination is not reliable across platforms. CSV files,
     * for example, are reported as text/plain under macOS but as application/vnd.ms-excel under
     * Windows. In some cases there might not be a mime type set at all (https://github.com/react-dropzone/react-dropzone/issues/276).
     */
    accept: PropTypes.objectOf(PropTypes.arrayOf(PropTypes.string)),
  
    /**
     * Allow drag 'n' drop (or selection from the file dialog) of multiple files
     */
    multiple: PropTypes.bool,
  
    /**
     * If false, allow dropped items to take over the current browser window
     */
    preventDropOnDocument: PropTypes.bool,
  
    /**
     * If true, disables click to open the native file selection dialog
     */
    noClick: PropTypes.bool,
  
    /**
     * If true, disables SPACE/ENTER to open the native file selection dialog.
     * Note that it also stops tracking the focus state.
     */
    noKeyboard: PropTypes.bool,
  
    /**
     * If true, disables drag 'n' drop
     */
    noDrag: PropTypes.bool,
  
    /**
     * If true, stops drag event propagation to parents
     */
    noDragEventsBubbling: PropTypes.bool,
  
    /**
     * Minimum file size (in bytes)
     */
    minSize: PropTypes.number,
  
    /**
     * Maximum file size (in bytes)
     */
    maxSize: PropTypes.number,
    /**
     * Maximum accepted number of files
     * The default value is 0 which means there is no limitation to how many files are accepted.
     */
    maxFiles: PropTypes.number,
  
    /**
     * Enable/disable the dropzone
     */
    disabled: PropTypes.bool,
  
    /**
     * Use this to provide a custom file aggregator
     *
     * @param {(DragEvent|Event|Array<FileSystemFileHandle>)} event A drag event or input change event (if files were selected via the file dialog)
     */
    getFilesFromEvent: PropTypes.func,
  
    /**
     * Cb for when closing the file dialog with no selection
     */
    onFileDialogCancel: PropTypes.func,
  
    /**
     * Cb for when opening the file dialog
     */
    onFileDialogOpen: PropTypes.func,
  
    /**
     * Set to true to use the https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API
     * to open the file picker instead of using an `<input type="file">` click event.
     */
    useFsAccessApi: PropTypes.bool,
  
    /**
     * Set to true to focus the root element on render
     */
    autoFocus: PropTypes.bool,
  
    /**
     * Cb for when the `dragenter` event occurs.
     *
     * @param {DragEvent} event
     */
    onDragEnter: PropTypes.func,
  
    /**
     * Cb for when the `dragleave` event occurs
     *
     * @param {DragEvent} event
     */
    onDragLeave: PropTypes.func,
  
    /**
     * Cb for when the `dragover` event occurs
     *
     * @param {DragEvent} event
     */
    onDragOver: PropTypes.func,
  
    /**
     * Cb for when the `drop` event occurs.
     * Note that this callback is invoked after the `getFilesFromEvent` callback is done.
     *
     * Files are accepted or rejected based on the `accept`, `multiple`, `minSize` and `maxSize` props.
     * `accept` must be a valid [MIME type](http://www.iana.org/assignments/media-types/media-types.xhtml) according to [input element specification](https://www.w3.org/wiki/HTML/Elements/input/file) or a valid file extension.
     * If `multiple` is set to false and additional files are dropped,
     * all files besides the first will be rejected.
     * Any file which does not have a size in the [`minSize`, `maxSize`] range, will be rejected as well.
     *
     * Note that the `onDrop` callback will always be invoked regardless if the dropped files were accepted or rejected.
     * If you'd like to react to a specific scenario, use the `onDropAccepted`/`onDropRejected` props.
     *
     * `onDrop` will provide you with an array of [File](https://developer.mozilla.org/en-US/docs/Web/API/File) objects which you can then process and send to a server.
     * For example, with [SuperAgent](https://github.com/visionmedia/superagent) as a http/ajax library:
     *
     * ```js
     * function onDrop(acceptedFiles) {
     *   const req = request.post('/upload')
     *   acceptedFiles.forEach(file => {
     *     req.attach(file.name, file)
     *   })
     *   req.end(callback)
     * }
     * ```
     *
     * @param {File[]} acceptedFiles
     * @param {FileRejection[]} fileRejections
     * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
     */
    onDrop: PropTypes.func,
  
    /**
     * Cb for when the `drop` event occurs.
     * Note that if no files are accepted, this callback is not invoked.
     *
     * @param {File[]} files
     * @param {(DragEvent|Event)} event
     */
    onDropAccepted: PropTypes.func,
  
    /**
     * Cb for when the `drop` event occurs.
     * Note that if no files are rejected, this callback is not invoked.
     *
     * @param {FileRejection[]} fileRejections
     * @param {(DragEvent|Event)} event
     */
    onDropRejected: PropTypes.func,
  
    /**
     * Cb for when there's some error from any of the promises.
     *
     * @param {Error} error
     */
    onError: PropTypes.func,
  
    /**
     * Custom validation function. It must return null if there's no errors.
     * @param {File} file
     * @returns {FileError|FileError[]|null}
     */
    validator: PropTypes.func,
  };
  
  export default Dropzone;
  
  /**
   * A function that is invoked for the `dragenter`,
   * `dragover` and `dragleave` events.
   * It is not invoked if the items are not files (such as link, text, etc.).
   *
   * @callback dragCb
   * @param {DragEvent} event
   */
  
  /**
   * A function that is invoked for the `drop` or input change event.
   * It is not invoked if the items are not files (such as link, text, etc.).
   *
   * @callback dropCb
   * @param {File[]} acceptedFiles List of accepted files
   * @param {FileRejection[]} fileRejections List of rejected files and why they were rejected. This is the authoritative source for post-drop file rejections.
   * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
   */
  
  /**
   * A function that is invoked for the `drop` or input change event.
   * It is not invoked if the items are files (such as link, text, etc.).
   *
   * @callback dropAcceptedCb
   * @param {File[]} files List of accepted files that meet the given criteria
   * (`accept`, `multiple`, `minSize`, `maxSize`)
   * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
   */
  
  /**
   * A function that is invoked for the `drop` or input change event.
   *
   * @callback dropRejectedCb
   * @param {File[]} files List of rejected files that do not meet the given criteria
   * (`accept`, `multiple`, `minSize`, `maxSize`)
   * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
   */
  
  /**
   * A function that is used aggregate files,
   * in a asynchronous fashion, from drag or input change events.
   *
   * @callback getFilesFromEvent
   * @param {(DragEvent|Event|Array<FileSystemFileHandle>)} event A drag event or input change event (if files were selected via the file dialog)
   * @returns {(File[]|Promise<File[]>)}
   */
  
  /**
   * An object with the current dropzone state.
   *
   * @typedef {object} DropzoneState
   * @property {boolean} isFocused Dropzone area is in focus
   * @property {boolean} isFileDialogActive File dialog is opened
   * @property {boolean} isDragActive Active drag is in progress
   * @property {boolean} isDragAccept Dragged files are accepted
   * @property {boolean} isDragReject True only during an active drag when some dragged files would be rejected. After drop, this resets to false. Use fileRejections for post-drop errors.
   * @property {boolean} isDragGlobal Files are being dragged anywhere on the document
   * @property {File[]} acceptedFiles Accepted files
   * @property {FileRejection[]} fileRejections Rejected files and why they were rejected. This persists after drop and is the source of truth for post-drop rejections.
   */
  
  /**
   * An object with the dropzone methods.
   *
   * @typedef {object} DropzoneMethods
   * @property {Function} getRootProps Returns the props you should apply to the root drop container you render
   * @property {Function} getInputProps Returns the props you should apply to hidden file input you render
   * @property {Function} open Open the native file selection dialog
   */
  
  const initialState = {
    isFocused: false,
    isFileDialogActive: false,
    isDragActive: false,
    isDragAccept: false,
    isDragReject: false,
    isDragGlobal: false,
    acceptedFiles: [],
    fileRejections: [],
  };
  
  /**
   * A React hook that creates a drag 'n' drop area.
   *
   * ```jsx
   * function MyDropzone(props) {
   *   const {getRootProps, getInputProps} = useDropzone({
   *     onDrop: acceptedFiles => {
   *       // do something with the File objects, e.g. upload to some server
   *     }
   *   });
   *   return (
   *     <div {...getRootProps()}>
   *       <input {...getInputProps()} />
   *       <p>Drag and drop some files here, or click to select files</p>
   *     </div>
   *   )
   * }
   * ```
   *
   * @function useDropzone
   *
   * @param {object} props
   * @param {import("./utils").AcceptProp} [props.accept] Set accepted file types.
   * Checkout https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker types option for more information.
   * Keep in mind that mime type determination is not reliable across platforms. CSV files,
   * for example, are reported as text/plain under macOS but as application/vnd.ms-excel under
   * Windows. In some cases there might not be a mime type set at all (https://github.com/react-dropzone/react-dropzone/issues/276).
   * @param {boolean} [props.multiple=true] Allow drag 'n' drop (or selection from the file dialog) of multiple files
   * @param {boolean} [props.preventDropOnDocument=true] If false, allow dropped items to take over the current browser window
   * @param {boolean} [props.noClick=false] If true, disables click to open the native file selection dialog
   * @param {boolean} [props.noKeyboard=false] If true, disables SPACE/ENTER to open the native file selection dialog.
   * Note that it also stops tracking the focus state.
   * @param {boolean} [props.noDrag=false] If true, disables drag 'n' drop
   * @param {boolean} [props.noDragEventsBubbling=false] If true, stops drag event propagation to parents
   * @param {number} [props.minSize=0] Minimum file size (in bytes)
   * @param {number} [props.maxSize=Infinity] Maximum file size (in bytes)
   * @param {boolean} [props.disabled=false] Enable/disable the dropzone
   * @param {getFilesFromEvent} [props.getFilesFromEvent] Use this to provide a custom file aggregator
   * @param {Function} [props.onFileDialogCancel] Cb for when closing the file dialog with no selection
   * @param {boolean} [props.useFsAccessApi] Set to true to use the https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API
   * to open the file picker instead of using an `<input type="file">` click event.
   * @param {boolean} autoFocus Set to true to auto focus the root element.
   * @param {Function} [props.onFileDialogOpen] Cb for when opening the file dialog
   * @param {dragCb} [props.onDragEnter] Cb for when the `dragenter` event occurs.
   * @param {dragCb} [props.onDragLeave] Cb for when the `dragleave` event occurs
   * @param {dragCb} [props.onDragOver] Cb for when the `dragover` event occurs
   * @param {dropCb} [props.onDrop] Cb for when the `drop` event occurs.
   * Note that this callback is invoked after the `getFilesFromEvent` callback is done.
   *
   * Files are accepted or rejected based on the `accept`, `multiple`, `minSize` and `maxSize` props.
   * `accept` must be an object with keys as a valid [MIME type](http://www.iana.org/assignments/media-types/media-types.xhtml) according to [input element specification](https://www.w3.org/wiki/HTML/Elements/input/file) and the value an array of file extensions (optional).
   * If `multiple` is set to false and additional files are dropped,
   * all files besides the first will be rejected.
   * Any file which does not have a size in the [`minSize`, `maxSize`] range, will be rejected as well.
   *
   * Note that the `onDrop` callback will always be invoked regardless if the dropped files were accepted or rejected.
   * If you'd like to react to a specific scenario, use the `onDropAccepted`/`onDropRejected` props.
   *
   * The second parameter (fileRejections) is the authoritative list of rejected files after a drop.
   * Use this parameter or the fileRejections state property to handle post-drop file rejections,
   * as isDragReject only indicates rejection state during active drag operations.
   *
   * `onDrop` will provide you with an array of [File](https://developer.mozilla.org/en-US/docs/Web/API/File) objects which you can then process and send to a server.
   * For example, with [SuperAgent](https://github.com/visionmedia/superagent) as a http/ajax library:
   *
   * ```js
   * function onDrop(acceptedFiles) {
   *   const req = request.post('/upload')
   *   acceptedFiles.forEach(file => {
   *     req.attach(file.name, file)
   *   })
   *   req.end(callback)
   * }
   * ```
   * @param {dropAcceptedCb} [props.onDropAccepted]
   * @param {dropRejectedCb} [props.onDropRejected]
   * @param {(error: Error) => void} [props.onError]
   *
   * @returns {DropzoneState & DropzoneMethods}
   */
  export function useDropzone(props = {}) {
    const {
      accept,
      disabled,
      getFilesFromEvent,
      maxSize,
      minSize,
      multiple,
      maxFiles,
      onDragEnter,
      onDragLeave,
      onDragOver,
      onDrop,
      onDropAccepted,
      onDropRejected,
      onFileDialogCancel,
      onFileDialogOpen,
      useFsAccessApi,
      autoFocus,
      preventDropOnDocument,
      noClick,
      noKeyboard,
      noDrag,
      noDragEventsBubbling,
      onError,
      validator,
    } = {
      ...defaultProps,
      ...props,
    };
  
    const acceptAttr = useMemo(() => acceptPropAsAcceptAttr(accept), [accept]);
    const pickerTypes = useMemo(() => pickerOptionsFromAccept(accept), [accept]);
  
    const onFileDialogOpenCb = useMemo(
      () => (typeof onFileDialogOpen === "function" ? onFileDialogOpen : noop),
      [onFileDialogOpen]
    );
    const onFileDialogCancelCb = useMemo(
      () =>
        typeof onFileDialogCancel === "function" ? onFileDialogCancel : noop,
      [onFileDialogCancel]
    );
  
    /**
     * @constant
     * @type {React.MutableRefObject<HTMLElement>}
     */
    const rootRef = useRef(null);
  
    const inputRef = useRef(null);
  
    const [state, dispatch] = useReducer(reducer, initialState);
    const { isFocused, isFileDialogActive } = state;
  
    const fsAccessApiWorksRef = useRef(
      typeof window !== "undefined" &&
        window.isSecureContext &&
        useFsAccessApi &&
        canUseFileSystemAccessAPI()
    );
  
    // Update file dialog active state when the window is focused on
    const onWindowFocus = () => {
      // Execute the timeout only if the file dialog is opened in the browser
      if (!fsAccessApiWorksRef.current && isFileDialogActive) {
        setTimeout(() => {
          if (inputRef.current) {
            const { files } = inputRef.current;
  
            if (!files.length) {
              dispatch({ type: "closeDialog" });
              onFileDialogCancelCb();
            }
          }
        }, 300);
      }
    };
    useEffect(() => {
      window.addEventListener("focus", onWindowFocus, false);
      return () => {
        window.removeEventListener("focus", onWindowFocus, false);
      };
    }, [inputRef, isFileDialogActive, onFileDialogCancelCb, fsAccessApiWorksRef]);
  
    const dragTargetsRef = useRef([]);
    const globalDragTargetsRef = useRef([]);
    const onDocumentDrop = (event) => {
      if (rootRef.current && rootRef.current.contains(event.target)) {
        // If we intercepted an event for our instance, let it propagate down to the instance's onDrop handler
        return;
      }
      event.preventDefault();
      dragTargetsRef.current = [];
    };
  
    useEffect(() => {
      if (preventDropOnDocument) {
        document.addEventListener("dragover", onDocumentDragOver, false);
        document.addEventListener("drop", onDocumentDrop, false);
      }
  
      return () => {
        if (preventDropOnDocument) {
          document.removeEventListener("dragover", onDocumentDragOver);
          document.removeEventListener("drop", onDocumentDrop);
        }
      };
    }, [rootRef, preventDropOnDocument]);
  
    // Track global drag state for document-level drag events
    useEffect(() => {
      const onDocumentDragEnter = (event) => {
        globalDragTargetsRef.current = [
          ...globalDragTargetsRef.current,
          event.target,
        ];
  
        if (isEvtWithFiles(event)) {
          dispatch({ isDragGlobal: true, type: "setDragGlobal" });
        }
      };
  
      const onDocumentDragLeave = (event) => {
        // Only deactivate once we've left all children
        globalDragTargetsRef.current = globalDragTargetsRef.current.filter(
          (el) => el !== event.target && el !== null
        );
  
        if (globalDragTargetsRef.current.length > 0) {
          return;
        }
  
        dispatch({ isDragGlobal: false, type: "setDragGlobal" });
      };
  
      const onDocumentDragEnd = () => {
        globalDragTargetsRef.current = [];
        dispatch({ isDragGlobal: false, type: "setDragGlobal" });
      };
  
      const onDocumentDropGlobal = () => {
        globalDragTargetsRef.current = [];
        dispatch({ isDragGlobal: false, type: "setDragGlobal" });
      };
  
      document.addEventListener("dragenter", onDocumentDragEnter, false);
      document.addEventListener("dragleave", onDocumentDragLeave, false);
      document.addEventListener("dragend", onDocumentDragEnd, false);
      document.addEventListener("drop", onDocumentDropGlobal, false);
  
      return () => {
        document.removeEventListener("dragenter", onDocumentDragEnter);
        document.removeEventListener("dragleave", onDocumentDragLeave);
        document.removeEventListener("dragend", onDocumentDragEnd);
        document.removeEventListener("drop", onDocumentDropGlobal);
      };
    }, [rootRef]);
  
    // Auto focus the root when autoFocus is true
    useEffect(() => {
      if (!disabled && autoFocus && rootRef.current) {
        rootRef.current.focus();
      }
      return () => {};
    }, [rootRef, autoFocus, disabled]);
  
    const onErrCb = useCallback(
      (e) => {
        if (onError) {
          onError(e);
        } else {
          // Let the user know something's gone wrong if they haven't provided the onError cb.
          console.error(e);
        }
      },
      [onError]
    );
  
    const onDragEnterCb = useCallback(
      (event) => {
        event.preventDefault();
        // Persist here because we need the event later after getFilesFromEvent() is done
        event.persist();
        stopPropagation(event);
  
        dragTargetsRef.current = [...dragTargetsRef.current, event.target];
  
        if (isEvtWithFiles(event)) {
          Promise.resolve(getFilesFromEvent(event))
            .then((files) => {
              if (isPropagationStopped(event) && !noDragEventsBubbling) {
                return;
              }
  
              const fileCount = files.length;
              const isDragAccept =
                fileCount > 0 &&
                allFilesAccepted({
                  files,
                  accept: acceptAttr,
                  minSize,
                  maxSize,
                  multiple,
                  maxFiles,
                  validator,
                });
              const isDragReject = fileCount > 0 && !isDragAccept;
  
              dispatch({
                isDragAccept,
                isDragReject,
                isDragActive: true,
                type: "setDraggedFiles",
              });
  
              if (onDragEnter) {
                onDragEnter(event);
              }
            })
            .catch((e) => onErrCb(e));
        }
      },
      [
        getFilesFromEvent,
        onDragEnter,
        onErrCb,
        noDragEventsBubbling,
        acceptAttr,
        minSize,
        maxSize,
        multiple,
        maxFiles,
        validator,
      ]
    );
  
    const onDragOverCb = useCallback(
      (event) => {
        event.preventDefault();
        event.persist();
        stopPropagation(event);
  
        const hasFiles = isEvtWithFiles(event);
        if (hasFiles && event.dataTransfer) {
          try {
            event.dataTransfer.dropEffect = "copy";
          } catch {} /* eslint-disable-line no-empty */
        }
  
        if (hasFiles && onDragOver) {
          onDragOver(event);
        }
  
        return false;
      },
      [onDragOver, noDragEventsBubbling]
    );
  
    const onDragLeaveCb = useCallback(
      (event) => {
        event.preventDefault();
        event.persist();
        stopPropagation(event);
  
        // Only deactivate once the dropzone and all children have been left
        const targets = dragTargetsRef.current.filter(
          (target) => rootRef.current && rootRef.current.contains(target)
        );
        // Make sure to remove a target present multiple times only once
        // (Firefox may fire dragenter/dragleave multiple times on the same element)
        const targetIdx = targets.indexOf(event.target);
        if (targetIdx !== -1) {
          targets.splice(targetIdx, 1);
        }
        dragTargetsRef.current = targets;
        if (targets.length > 0) {
          return;
        }
  
        dispatch({
          type: "setDraggedFiles",
          isDragActive: false,
          isDragAccept: false,
          isDragReject: false,
        });
  
        if (isEvtWithFiles(event) && onDragLeave) {
          onDragLeave(event);
        }
      },
      [rootRef, onDragLeave, noDragEventsBubbling]
    );
  
    const setFiles = useCallback(
      (files, event) => {
        const acceptedFiles = [];
        const fileRejections = [];
  
        files.forEach((file) => {
          const [accepted, acceptError] = fileAccepted(file, acceptAttr);
          const [sizeMatch, sizeError] = fileMatchSize(file, minSize, maxSize);
          const customErrors = validator ? validator(file) : null;
  
          if (accepted && sizeMatch && !customErrors) {
            acceptedFiles.push(file);
          } else {
            let errors = [acceptError, sizeError];
  
            if (customErrors) {
              errors = errors.concat(customErrors);
            }
  
            fileRejections.push({ file, errors: errors.filter((e) => e) });
          }
        });
  
        if (
          (!multiple && acceptedFiles.length > 1) ||
          (multiple && maxFiles >= 1 && acceptedFiles.length > maxFiles)
        ) {
          // Reject everything and empty accepted files
          acceptedFiles.forEach((file) => {
            fileRejections.push({ file, errors: [TOO_MANY_FILES_REJECTION] });
          });
          acceptedFiles.splice(0);
        }
  
        dispatch({
          acceptedFiles,
          fileRejections,
          type: "setFiles",
        });
  
        if (onDrop) {
          onDrop(acceptedFiles, fileRejections, event);
        }
  
        if (fileRejections.length > 0 && onDropRejected) {
          onDropRejected(fileRejections, event);
        }
  
        if (acceptedFiles.length > 0 && onDropAccepted) {
          onDropAccepted(acceptedFiles, event);
        }
      },
      [
        dispatch,
        multiple,
        acceptAttr,
        minSize,
        maxSize,
        maxFiles,
        onDrop,
        onDropAccepted,
        onDropRejected,
        validator,
      ]
    );
  
    const onDropCb = useCallback(
      (event) => {
        event.preventDefault();
        // Persist here because we need the event later after getFilesFromEvent() is done
        event.persist();
        stopPropagation(event);
  
        dragTargetsRef.current = [];
  
        if (isEvtWithFiles(event)) {
          Promise.resolve(getFilesFromEvent(event))
            .then((files) => {
              if (isPropagationStopped(event) && !noDragEventsBubbling) {
                return;
              }
              setFiles(files, event);
            })
            .catch((e) => onErrCb(e));
        }
        dispatch({ type: "reset" });
      },
      [getFilesFromEvent, setFiles, onErrCb, noDragEventsBubbling]
    );
  
    // Fn for opening the file dialog programmatically
    const openFileDialog = useCallback(() => {
      // No point to use FS access APIs if context is not secure
      // https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts#feature_detection
      if (fsAccessApiWorksRef.current) {
        dispatch({ type: "openDialog" });
        onFileDialogOpenCb();
        // https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker
        const opts = {
          multiple,
          types: pickerTypes,
        };
        window
          .showOpenFilePicker(opts)
          .then((handles) => getFilesFromEvent(handles))
          .then((files) => {
            setFiles(files, null);
            dispatch({ type: "closeDialog" });
          })
          .catch((e) => {
            // AbortError means the user canceled
            if (isAbort(e)) {
              onFileDialogCancelCb(e);
              dispatch({ type: "closeDialog" });
            } else if (isSecurityError(e)) {
              fsAccessApiWorksRef.current = false;
              // CORS, so cannot use this API
              // Try using the input
              if (inputRef.current) {
                inputRef.current.value = null;
                inputRef.current.click();
              } else {
                onErrCb(
                  new Error(
                    "Cannot open the file picker because the https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API is not supported and no <input> was provided."
                  )
                );
              }
            } else {
              onErrCb(e);
            }
          });
        return;
      }
  
      if (inputRef.current) {
        dispatch({ type: "openDialog" });
        onFileDialogOpenCb();
        inputRef.current.value = null;
        inputRef.current.click();
      }
    }, [
      dispatch,
      onFileDialogOpenCb,
      onFileDialogCancelCb,
      useFsAccessApi,
      setFiles,
      onErrCb,
      pickerTypes,
      multiple,
    ]);
  
    // Cb to open the file dialog when SPACE/ENTER occurs on the dropzone
    const onKeyDownCb = useCallback(
      (event) => {
        // Ignore keyboard events bubbling up the DOM tree
        if (!rootRef.current || !rootRef.current.isEqualNode(event.target)) {
          return;
        }
  
        if (
          event.key === " " ||
          event.key === "Enter" ||
          event.keyCode === 32 ||
          event.keyCode === 13
        ) {
          event.preventDefault();
          openFileDialog();
        }
      },
      [rootRef, openFileDialog]
    );
  
    // Update focus state for the dropzone
    const onFocusCb = useCallback(() => {
      dispatch({ type: "focus" });
    }, []);
    const onBlurCb = useCallback(() => {
      dispatch({ type: "blur" });
    }, []);
  
    // Cb to open the file dialog when click occurs on the dropzone
    const onClickCb = useCallback(() => {
      if (noClick) {
        return;
      }
  
      // In IE11/Edge the file-browser dialog is blocking, therefore, use setTimeout()
      // to ensure React can handle state changes
      // See: https://github.com/react-dropzone/react-dropzone/issues/450
      if (isIeOrEdge()) {
        setTimeout(openFileDialog, 0);
      } else {
        openFileDialog();
      }
    }, [noClick, openFileDialog]);
  
    const composeHandler = (fn) => {
      return disabled ? null : fn;
    };
  
    const composeKeyboardHandler = (fn) => {
      return noKeyboard ? null : composeHandler(fn);
    };
  
    const composeDragHandler = (fn) => {
      return noDrag ? null : composeHandler(fn);
    };
  
    const stopPropagation = (event) => {
      if (noDragEventsBubbling) {
        event.stopPropagation();
      }
    };
  
    const getRootProps = useMemo(
      () =>
        ({
          refKey = "ref",
          role,
          onKeyDown,
          onFocus,
          onBlur,
          onClick,
          onDragEnter,
          onDragOver,
          onDragLeave,
          onDrop,
          ...rest
        } = {}) => ({
          onKeyDown: composeKeyboardHandler(
            composeEventHandlers(onKeyDown, onKeyDownCb)
          ),
          onFocus: composeKeyboardHandler(
            composeEventHandlers(onFocus, onFocusCb)
          ),
          onBlur: composeKeyboardHandler(composeEventHandlers(onBlur, onBlurCb)),
          onClick: composeHandler(composeEventHandlers(onClick, onClickCb)),
          onDragEnter: composeDragHandler(
            composeEventHandlers(onDragEnter, onDragEnterCb)
          ),
          onDragOver: composeDragHandler(
            composeEventHandlers(onDragOver, onDragOverCb)
          ),
          onDragLeave: composeDragHandler(
            composeEventHandlers(onDragLeave, onDragLeaveCb)
          ),
          onDrop: composeDragHandler(composeEventHandlers(onDrop, onDropCb)),
          role: typeof role === "string" && role !== "" ? role : "presentation",
          [refKey]: rootRef,
          ...(!disabled && !noKeyboard ? { tabIndex: 0 } : {}),
          ...rest,
        }),
      [
        rootRef,
        onKeyDownCb,
        onFocusCb,
        onBlurCb,
        onClickCb,
        onDragEnterCb,
        onDragOverCb,
        onDragLeaveCb,
        onDropCb,
        noKeyboard,
        noDrag,
        disabled,
      ]
    );
  
    const onInputElementClick = useCallback((event) => {
      event.stopPropagation();
    }, []);
  
    const getInputProps = useMemo(
      () =>
        ({ refKey = "ref", onChange, onClick, ...rest } = {}) => {
          const inputProps = {
            accept: acceptAttr,
            multiple,
            type: "file",
            style: {
              border: 0,
              clip: "rect(0, 0, 0, 0)",
              clipPath: "inset(50%)",
              height: "1px",
              margin: "0 -1px -1px 0",
              overflow: "hidden",
              padding: 0,
              position: "absolute",
              width: "1px",
              whiteSpace: "nowrap",
            },
            onChange: composeHandler(composeEventHandlers(onChange, onDropCb)),
            onClick: composeHandler(
              composeEventHandlers(onClick, onInputElementClick)
            ),
            tabIndex: -1,
            [refKey]: inputRef,
          };
  
          return {
            ...inputProps,
            ...rest,
          };
        },
      [inputRef, accept, multiple, onDropCb, disabled]
    );
  
    return {
      ...state,
      isFocused: isFocused && !disabled,
      getRootProps,
      getInputProps,
      rootRef,
      inputRef,
      open: composeHandler(openFileDialog),
    };
  }
  
  /**
   * @param {DropzoneState} state
   * @param {{type: string} & DropzoneState} action
   * @returns {DropzoneState}
   */
  function reducer(state, action) {
    /* istanbul ignore next */
    switch (action.type) {
      case "focus":
        return {
          ...state,
          isFocused: true,
        };
      case "blur":
        return {
          ...state,
          isFocused: false,
        };
      case "openDialog":
        return {
          ...initialState,
          isFileDialogActive: true,
        };
      case "closeDialog":
        return {
          ...state,
          isFileDialogActive: false,
        };
      case "setDraggedFiles":
        return {
          ...state,
          isDragActive: action.isDragActive,
          isDragAccept: action.isDragAccept,
          isDragReject: action.isDragReject,
        };
      case "setFiles":
        return {
          ...state,
          acceptedFiles: action.acceptedFiles,
          fileRejections: action.fileRejections,
          isDragReject: false,
        };
      case "setDragGlobal":
        return {
          ...state,
          isDragGlobal: action.isDragGlobal,
        };
      case "reset":
        return {
          ...initialState,
        };
      default:
        return state;
    }
  }
  
  function noop() {}
  
  export { ErrorCode } from "./utils/index.js";
  