react-dropzone 15.0.0 → 16.0.0

package/dist/es/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/es/utils/index.js

@@ -1,366 +0,0 @@
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-import _accepts from "attr-accept";
-var accepts = typeof _accepts === "function" ? _accepts : _accepts.default; // Error codes
-
-export var FILE_INVALID_TYPE = "file-invalid-type";
-export var FILE_TOO_LARGE = "file-too-large";
-export var FILE_TOO_SMALL = "file-too-small";
-export var TOO_MANY_FILES = "too-many-files";
-export var ErrorCode = {
-  FileInvalidType: FILE_INVALID_TYPE,
-  FileTooLarge: FILE_TOO_LARGE,
-  FileTooSmall: FILE_TOO_SMALL,
-  TooManyFiles: TOO_MANY_FILES
-};
-/**
- *
- * @param {string} accept
- */
-
-export var getInvalidTypeRejectionErr = function getInvalidTypeRejectionErr() {
-  var accept = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
-  var acceptArr = accept.split(",");
-  var msg = acceptArr.length > 1 ? "one of ".concat(acceptArr.join(", ")) : acceptArr[0];
-  return {
-    code: FILE_INVALID_TYPE,
-    message: "File type must be ".concat(msg)
-  };
-};
-export var getTooLargeRejectionErr = function getTooLargeRejectionErr(maxSize) {
-  return {
-    code: FILE_TOO_LARGE,
-    message: "File is larger than ".concat(maxSize, " ").concat(maxSize === 1 ? "byte" : "bytes")
-  };
-};
-export var getTooSmallRejectionErr = function getTooSmallRejectionErr(minSize) {
-  return {
-    code: FILE_TOO_SMALL,
-    message: "File is smaller than ".concat(minSize, " ").concat(minSize === 1 ? "byte" : "bytes")
-  };
-};
-export var TOO_MANY_FILES_REJECTION = {
-  code: TOO_MANY_FILES,
-  message: "Too many files"
-};
-/**
- * Check if the given file is a DataTransferItem with an empty type.
- *
- * During drag events, browsers may return DataTransferItem objects instead of File objects.
- * Some browsers (e.g., Chrome) return an empty MIME type for certain file types (like .md files)
- * on DataTransferItem during drag events, even though the type is correctly set during drop.
- *
- * This function detects such cases by checking for:
- * 1. Empty type string
- * 2. Presence of getAsFile method (indicates it's a DataTransferItem, not a File)
- *
- * We accept these during drag to provide proper UI feedback, while maintaining
- * strict validation during drop when real File objects are available.
- *
- * @param {File | DataTransferItem} file
- * @returns {boolean}
- */
-
-export function isDataTransferItemWithEmptyType(file) {
-  return file.type === "" && typeof file.getAsFile === "function";
-}
-/**
- * Check if file is accepted.
- *
- * Firefox versions prior to 53 return a bogus MIME type for every file drag,
- * so dragovers with that MIME type will always be accepted.
- *
- * Chrome/other browsers may return an empty MIME type for files during drag events,
- * so we accept those as well (we'll validate properly on drop).
- *
- * @param {File} file
- * @param {string} accept
- * @returns
- */
-
-export function fileAccepted(file, accept) {
-  var isAcceptable = file.type === "application/x-moz-file" || accepts(file, accept) || isDataTransferItemWithEmptyType(file);
-  return [isAcceptable, isAcceptable ? null : getInvalidTypeRejectionErr(accept)];
-}
-export function fileMatchSize(file, minSize, maxSize) {
-  if (isDefined(file.size)) {
-    if (isDefined(minSize) && isDefined(maxSize)) {
-      if (file.size > maxSize) return [false, getTooLargeRejectionErr(maxSize)];
-      if (file.size < minSize) return [false, getTooSmallRejectionErr(minSize)];
-    } else if (isDefined(minSize) && file.size < minSize) return [false, getTooSmallRejectionErr(minSize)];else if (isDefined(maxSize) && file.size > maxSize) return [false, getTooLargeRejectionErr(maxSize)];
-  }
-
-  return [true, null];
-}
-
-function isDefined(value) {
-  return value !== undefined && value !== null;
-}
-/**
- *
- * @param {object} options
- * @param {File[]} options.files
- * @param {string} [options.accept]
- * @param {number} [options.minSize]
- * @param {number} [options.maxSize]
- * @param {boolean} [options.multiple]
- * @param {number} [options.maxFiles]
- * @param {(f: File) => FileError|FileError[]|null} [options.validator]
- * @returns
- */
-
-
-export function allFilesAccepted(_ref) {
-  var files = _ref.files,
-      accept = _ref.accept,
-      minSize = _ref.minSize,
-      maxSize = _ref.maxSize,
-      multiple = _ref.multiple,
-      maxFiles = _ref.maxFiles,
-      validator = _ref.validator;
-
-  if (!multiple && files.length > 1 || multiple && maxFiles >= 1 && files.length > maxFiles) {
-    return false;
-  }
-
-  return files.every(function (file) {
-    var _fileAccepted = fileAccepted(file, accept),
-        _fileAccepted2 = _slicedToArray(_fileAccepted, 1),
-        accepted = _fileAccepted2[0];
-
-    var _fileMatchSize = fileMatchSize(file, minSize, maxSize),
-        _fileMatchSize2 = _slicedToArray(_fileMatchSize, 1),
-        sizeMatch = _fileMatchSize2[0];
-
-    var customErrors = validator ? validator(file) : null;
-    return accepted && sizeMatch && !customErrors;
-  });
-} // React's synthetic events has event.isPropagationStopped,
-// but to remain compatibility with other libs (Preact) fall back
-// to check event.cancelBubble
-
-export function isPropagationStopped(event) {
-  if (typeof event.isPropagationStopped === "function") {
-    return event.isPropagationStopped();
-  } else if (typeof event.cancelBubble !== "undefined") {
-    return event.cancelBubble;
-  }
-
-  return false;
-}
-export function isEvtWithFiles(event) {
-  if (!event.dataTransfer) {
-    return !!event.target && !!event.target.files;
-  } // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/types
-  // https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/Recommended_drag_types#file
-
-
-  return Array.prototype.some.call(event.dataTransfer.types, function (type) {
-    return type === "Files" || type === "application/x-moz-file";
-  });
-}
-export function isKindFile(item) {
-  return _typeof(item) === "object" && item !== null && item.kind === "file";
-} // allow the entire document to be a drag target
-
-export function onDocumentDragOver(event) {
-  event.preventDefault();
-}
-
-function isIe(userAgent) {
-  return userAgent.indexOf("MSIE") !== -1 || userAgent.indexOf("Trident/") !== -1;
-}
-
-function isEdge(userAgent) {
-  return userAgent.indexOf("Edge/") !== -1;
-}
-
-export function isIeOrEdge() {
-  var userAgent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.navigator.userAgent;
-  return isIe(userAgent) || isEdge(userAgent);
-}
-/**
- * This is intended to be used to compose event handlers
- * They are executed in order until one of them calls `event.isPropagationStopped()`.
- * Note that the check is done on the first invoke too,
- * meaning that if propagation was stopped before invoking the fns,
- * no handlers will be executed.
- *
- * @param {Function} fns the event hanlder functions
- * @return {Function} the event handler to add to an element
- */
-
-export function composeEventHandlers() {
-  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
-    fns[_key] = arguments[_key];
-  }
-
-  return function (event) {
-    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-      args[_key2 - 1] = arguments[_key2];
-    }
-
-    return fns.some(function (fn) {
-      if (!isPropagationStopped(event) && fn) {
-        fn.apply(void 0, [event].concat(args));
-      }
-
-      return isPropagationStopped(event);
-    });
-  };
-}
-/**
- * canUseFileSystemAccessAPI checks if the [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API)
- * is supported by the browser.
- * @returns {boolean}
- */
-
-export function canUseFileSystemAccessAPI() {
-  return "showOpenFilePicker" in window;
-}
-/**
- * Convert the `{accept}` dropzone prop to the
- * `{types}` option for https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker
- *
- * @param {AcceptProp} accept
- * @returns {{accept: string[]}[]}
- */
-
-export function pickerOptionsFromAccept(accept) {
-  if (isDefined(accept)) {
-    var acceptForPicker = Object.entries(accept).filter(function (_ref2) {
-      var _ref3 = _slicedToArray(_ref2, 2),
-          mimeType = _ref3[0],
-          ext = _ref3[1];
-
-      var ok = true;
-
-      if (!isMIMEType(mimeType)) {
-        console.warn("Skipped \"".concat(mimeType, "\" because it is not a valid MIME type. Check https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types for a list of valid MIME types."));
-        ok = false;
-      }
-
-      if (!Array.isArray(ext) || !ext.every(isExt)) {
-        console.warn("Skipped \"".concat(mimeType, "\" because an invalid file extension was provided."));
-        ok = false;
-      }
-
-      return ok;
-    }).reduce(function (agg, _ref4) {
-      var _ref5 = _slicedToArray(_ref4, 2),
-          mimeType = _ref5[0],
-          ext = _ref5[1];
-
-      return _objectSpread(_objectSpread({}, agg), {}, _defineProperty({}, mimeType, ext));
-    }, {});
-    return [{
-      // description is required due to https://crbug.com/1264708
-      description: "Files",
-      accept: acceptForPicker
-    }];
-  }
-
-  return accept;
-}
-/**
- * Convert the `{accept}` dropzone prop to an array of MIME types/extensions.
- * @param {AcceptProp} accept
- * @returns {string}
- */
-
-export function acceptPropAsAcceptAttr(accept) {
-  if (isDefined(accept)) {
-    return Object.entries(accept).reduce(function (a, _ref6) {
-      var _ref7 = _slicedToArray(_ref6, 2),
-          mimeType = _ref7[0],
-          ext = _ref7[1];
-
-      return [].concat(_toConsumableArray(a), [mimeType], _toConsumableArray(ext));
-    }, []) // Silently discard invalid entries as pickerOptionsFromAccept warns about these
-    .filter(function (v) {
-      return isMIMEType(v) || isExt(v);
-    }).join(",");
-  }
-
-  return undefined;
-}
-/**
- * Check if v is an exception caused by aborting a request (e.g window.showOpenFilePicker()).
- *
- * See https://developer.mozilla.org/en-US/docs/Web/API/DOMException.
- * @param {any} v
- * @returns {boolean} True if v is an abort exception.
- */
-
-export function isAbort(v) {
-  return v instanceof DOMException && (v.name === "AbortError" || v.code === v.ABORT_ERR);
-}
-/**
- * Check if v is a security error.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/API/DOMException.
- * @param {any} v
- * @returns {boolean} True if v is a security error.
- */
-
-export function isSecurityError(v) {
-  return v instanceof DOMException && (v.name === "SecurityError" || v.code === v.SECURITY_ERR);
-}
-/**
- * Check if v is a MIME type string.
- *
- * See accepted format: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#unique_file_type_specifiers.
- *
- * @param {string} v
- */
-
-export function isMIMEType(v) {
-  return v === "audio/*" || v === "video/*" || v === "image/*" || v === "text/*" || v === "application/*" || /\w+\/[-+.\w]+/g.test(v);
-}
-/**
- * Check if v is a file extension.
- * @param {string} v
- */
-
-export function isExt(v) {
-  return /^.*\.[\w]+$/.test(v);
-}
-/**
- * @typedef {Object.<string, string[]>} AcceptProp
- */
-
-/**
- * @typedef {object} FileError
- * @property {string} message
- * @property {ErrorCode|string} code
- */
-
-/**
- * @typedef {"file-invalid-type"|"file-too-large"|"file-too-small"|"too-many-files"} ErrorCode
- */

package/examples/.eslintrc

@@ -1,5 +0,0 @@
-{
-  "globals": {
-    "useDropzone": true
-  }
-}

package/examples/accept/README.md

@@ -1,144 +0,0 @@
-By providing `accept` prop you can make the dropzone accept specific file types and reject the others.
-
-The value must be an object with a common [MIME type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types) as keys and an array of file extensions as values (similar to [showOpenFilePicker](https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker)'s types `accept` option).
-```js static
-useDropzone({
-  accept: {
-    'image/png': ['.png'],
-    'text/html': ['.html', '.htm'],
-  }
-})
-```
-
-For more information see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Input.
-
-```jsx harmony
-import React from 'react';
-import {useDropzone} from 'react-dropzone';
-
-function Accept(props) {
-  const {
-    acceptedFiles,
-    fileRejections,
-    getRootProps,
-    getInputProps
-  } = useDropzone({
-    accept: {
-      'image/jpeg': [],
-      'image/png': []
-    }
-  });
-
-  const acceptedFileItems = acceptedFiles.map(file => (
-    <li key={file.path}>
-      {file.path} - {file.size} bytes
-    </li>
-  ));
-
-  const fileRejectionItems = fileRejections.map(({ file, errors }) => (
-    <li key={file.path}>
-      {file.path} - {file.size} bytes
-      <ul>
-        {errors.map(e => (
-          <li key={e.code}>{e.message}</li>
-        ))}
-      </ul>
-    </li>
-  ));
-
-  return (
-    <section className="container">
-      <div {...getRootProps({ className: 'dropzone' })}>
-        <input {...getInputProps()} />
-        <p>Drag 'n' drop some files here, or click to select files</p>
-        <em>(Only *.jpeg and *.png images will be accepted)</em>
-      </div>
-      <aside>
-        <h4>Accepted files</h4>
-        <ul>{acceptedFileItems}</ul>
-        <h4>Rejected files</h4>
-        <ul>{fileRejectionItems}</ul>
-      </aside>
-    </section>
-  );
-}
-
-<Accept />
-```
-
-### Browser limitations
-
-Because of HTML5 File API differences across different browsers during the drag, Dropzone might not be able to detect whether the files are accepted or rejected in Safari nor IE.
-
-Furthermore, at this moment it's not possible to read file names (and thus, file extensions) during the drag operation. For that reason, if you want to react on different file types _during_ the drag operation, _you have to use_ mime types and not extensions! For example, the following example won't work even in Chrome:
-
-```jsx harmony
-import React from 'react';
-import {useDropzone} from 'react-dropzone';
-
-function Accept(props) {
-  const {
-    getRootProps,
-    getInputProps,
-    isDragActive,
-    isDragAccept,
-    isDragReject
-  } = useDropzone({
-    accept: {
-      'image/jpeg': ['.jpeg', '.png']
-    }
-  });
-
-  return (
-    <div className="container">
-      <div {...getRootProps({className: 'dropzone'})}>
-        <input {...getInputProps()} />
-        {isDragAccept && (<p>All files will be accepted</p>)}
-        {isDragReject && (<p>Some files will be rejected</p>)}
-        {!isDragActive && (<p>Drop some files here ...</p>)}
-      </div>
-    </div>
-  );
-}
-
-<Accept />
-```
-
-but this one will:
-
-```jsx harmony
-import React from 'react';
-import {useDropzone} from 'react-dropzone';
-
-function Accept(props) {
-  const {
-    getRootProps,
-    getInputProps,
-    isDragActive,
-    isDragAccept,
-    isDragReject
-  } = useDropzone({
-    accept: {
-      'image/*': ['.jpeg', '.png']
-    }
-  });
-
-  return (
-    <div className="container">
-      <div {...getRootProps({className: "dropzone"})}>
-        <input {...getInputProps()} />
-        {isDragAccept && (<p>All files will be accepted</p>)}
-          {isDragReject && (<p>Some files will be rejected</p>)}
-          {!isDragActive && (<p>Drop some files here ...</p>)}
-      </div>
-    </div>
-  );
-}
-
-<Accept />
-```
-
-### Notes
-
-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.
-

package/examples/basic/README.md

@@ -1,70 +0,0 @@
-The `useDropzone` hook just binds the necessary handlers to create a drag 'n' drop zone.
-Use the `getRootProps()` fn to get the props required for drag 'n' drop and use them on any element.
-For click and keydown behavior, use the `getInputProps()` fn and use the returned props on an `<input>`.
-
-Furthermore, the hook supports folder drag 'n' drop by default. See [file-selector](https://github.com/react-dropzone/file-selector) for more info about supported browsers.
-
-
-```jsx harmony
-import React from 'react';
-import {useDropzone} from 'react-dropzone';
-
-function Basic(props) {
-  const {acceptedFiles, getRootProps, getInputProps} = useDropzone();
-  
-  const files = acceptedFiles.map(file => (
-    <li key={file.path}>
-      {file.path} - {file.size} bytes
-    </li>
-  ));
-
-  return (
-    <section className="container">
-      <div {...getRootProps({className: 'dropzone'})}>
-        <input {...getInputProps()} />
-        <p>Drag 'n' drop some files here, or click to select files</p>
-      </div>
-      <aside>
-        <h4>Files</h4>
-        <ul>{files}</ul>
-      </aside>
-    </section>
-  );
-}
-
-<Basic />
-```
-
-Dropzone with `disabled` property:
-
-```jsx harmony
-import React from 'react';
-import {useDropzone} from 'react-dropzone';
-
-function Basic(props) {
-  const {acceptedFiles, getRootProps, getInputProps} = useDropzone({
-    disabled: true
-  });
-
-  const files = acceptedFiles.map(file => (
-    <li key={file.name}>
-      {file.name} - {file.size} bytes
-    </li>
-  ));
-
-  return (
-    <section className="container">
-      <div {...getRootProps({className: 'dropzone disabled'})}>
-        <input {...getInputProps()} />
-        <p>Drag 'n' drop some files here, or click to select files</p>
-      </div>
-      <aside>
-        <h4>Files</h4>
-        <ul>{files}</ul>
-      </aside>
-    </section>
-  );
-}
-
-<Basic />
-```

package/examples/class-component/README.md

@@ -1,45 +0,0 @@
-If you're still using class components, you can use the [`<Dropzone>`](https://react-dropzone.js.org/#components) component provided by the lib:
-
-```jsx harmony
-import React, {Component} from 'react';
-import Dropzone from 'react-dropzone';
-
-class Basic extends Component {
-  constructor() {
-    super();
-    this.onDrop = (files) => {
-      this.setState({files})
-    };
-    this.state = {
-      files: []
-    };
-  }
-
-  render() {
-    const files = this.state.files.map(file => (
-      <li key={file.name}>
-        {file.name} - {file.size} bytes
-      </li>
-    ));
-
-    return (
-      <Dropzone onDrop={this.onDrop}>
-        {({getRootProps, getInputProps}) => (
-          <section className="container">
-            <div {...getRootProps({className: 'dropzone'})}>
-              <input {...getInputProps()} />
-              <p>Drag 'n' drop some files here, or click to select files</p>
-            </div>
-            <aside>
-              <h4>Files</h4>
-              <ul>{files}</ul>
-            </aside>
-          </section>
-        )}
-      </Dropzone>
-    );
-  }
-}
-
-<Basic />
-```