1import { r as reactExports, a as React } from "./react-CuY1Cvos.js"; 2import { P as PropTypes } from "./prop-types-BnWbMLOC.js"; 3import { f as fromEvent } from "./file-selector-BHBOGph1.js"; 4import { _ as _default } from "./attr-accept-Bocw6vBy.js"; 5function _toConsumableArray$1(arr) { 6 return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread$1(); 7} 8function _nonIterableSpread$1() { 9 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 10} 11function _iterableToArray$1(iter) { 12 if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) 13 return Array.from(iter); 14} 15function _arrayWithoutHoles$1(arr) { 16 if (Array.isArray(arr)) 17 return _arrayLikeToArray$1(arr); 18} 19function ownKeys$1(object, enumerableOnly) { 20 var keys = Object.keys(object); 21 if (Object.getOwnPropertySymbols) { 22 var symbols = Object.getOwnPropertySymbols(object); 23 enumerableOnly && (symbols = symbols.filter(function(sym) { 24 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 25 })), keys.push.apply(keys, symbols); 26 } 27 return keys; 28} 29function _objectSpread$1(target) { 30 for (var i = 1; i < arguments.length; i++) { 31 var source = null != arguments[i] ? arguments[i] : {}; 32 i % 2 ? ownKeys$1(Object(source), true).forEach(function(key) { 33 _defineProperty$1(target, key, source[key]); 34 }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function(key) { 35 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 36 }); 37 } 38 return target; 39} 40function _defineProperty$1(obj, key, value) { 41 if (key in obj) { 42 Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); 43 } else { 44 obj[key] = value; 45 } 46 return obj; 47} 48function _slicedToArray$1(arr, i) { 49 return _arrayWithHoles$1(arr) || _iterableToArrayLimit$1(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest$1(); 50} 51function _nonIterableRest$1() { 52 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 53} 54function _unsupportedIterableToArray$1(o, minLen) { 55 if (!o) 56 return; 57 if (typeof o === "string") 58 return _arrayLikeToArray$1(o, minLen); 59 var n = Object.prototype.toString.call(o).slice(8, -1); 60 if (n === "Object" && o.constructor) 61 n = o.constructor.name; 62 if (n === "Map" || n === "Set") 63 return Array.from(o); 64 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) 65 return _arrayLikeToArray$1(o, minLen); 66} 67function _arrayLikeToArray$1(arr, len) { 68 if (len == null || len > arr.length) 69 len = arr.length; 70 for (var i = 0, arr2 = new Array(len); i < len; i++) { 71 arr2[i] = arr[i]; 72 } 73 return arr2; 74} 75function _iterableToArrayLimit$1(arr, i) { 76 var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; 77 if (_i == null) 78 return; 79 var _arr = []; 80 var _n = true; 81 var _d = false; 82 var _s, _e; 83 try { 84 for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { 85 _arr.push(_s.value); 86 if (i && _arr.length === i) 87 break; 88 } 89 } catch (err) { 90 _d = true; 91 _e = err; 92 } finally { 93 try { 94 if (!_n && _i["return"] != null) 95 _i["return"](); 96 } finally { 97 if (_d) 98 throw _e; 99 } 100 } 101 return _arr; 102} 103function _arrayWithHoles$1(arr) { 104 if (Array.isArray(arr)) 105 return arr; 106} 107var accepts = typeof _default === "function" ? _default : _default.default; 108var FILE_INVALID_TYPE = "file-invalid-type"; 109var FILE_TOO_LARGE = "file-too-large"; 110var FILE_TOO_SMALL = "file-too-small"; 111var TOO_MANY_FILES = "too-many-files"; 112var getInvalidTypeRejectionErr = function getInvalidTypeRejectionErr2() { 113 var accept = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ""; 114 var acceptArr = accept.split(","); 115 var msg = acceptArr.length > 1 ? "one of ".concat(acceptArr.join(", ")) : acceptArr[0]; 116 return { 117 code: FILE_INVALID_TYPE, 118 message: "File type must be ".concat(msg) 119 }; 120}; 121var getTooLargeRejectionErr = function getTooLargeRejectionErr2(maxSize) { 122 return { 123 code: FILE_TOO_LARGE, 124 message: "File is larger than ".concat(maxSize, " ").concat(maxSize === 1 ? "byte" : "bytes") 125 }; 126}; 127var getTooSmallRejectionErr = function getTooSmallRejectionErr2(minSize) { 128 return { 129 code: FILE_TOO_SMALL, 130 message: "File is smaller than ".concat(minSize, " ").concat(minSize === 1 ? "byte" : "bytes") 131 }; 132}; 133var TOO_MANY_FILES_REJECTION = { 134 code: TOO_MANY_FILES, 135 message: "Too many files" 136}; 137function isDataTransferItemWithEmptyType(file) { 138 return file.type === "" && typeof file.getAsFile === "function"; 139} 140function fileAccepted(file, accept) { 141 var isAcceptable = file.type === "application/x-moz-file" || accepts(file, accept) || isDataTransferItemWithEmptyType(file); 142 return [isAcceptable, isAcceptable ? null : getInvalidTypeRejectionErr(accept)]; 143} 144function fileMatchSize(file, minSize, maxSize) { 145 if (isDefined(file.size)) { 146 if (isDefined(minSize) && isDefined(maxSize)) { 147 if (file.size > maxSize) 148 return [false, getTooLargeRejectionErr(maxSize)]; 149 if (file.size < minSize) 150 return [false, getTooSmallRejectionErr(minSize)]; 151 } else if (isDefined(minSize) && file.size < minSize) 152 return [false, getTooSmallRejectionErr(minSize)]; 153 else if (isDefined(maxSize) && file.size > maxSize) 154 return [false, getTooLargeRejectionErr(maxSize)]; 155 } 156 return [true, null]; 157} 158function isDefined(value) { 159 return value !== void 0 && value !== null; 160} 161function allFilesAccepted(_ref) { 162 var files = _ref.files, accept = _ref.accept, minSize = _ref.minSize, maxSize = _ref.maxSize, multiple = _ref.multiple, maxFiles = _ref.maxFiles, validator = _ref.validator; 163 if (!multiple && files.length > 1 || multiple && maxFiles >= 1 && files.length > maxFiles) { 164 return false;
165 } 166 return files.every(function(file) { 167 var _fileAccepted = fileAccepted(file, accept), _fileAccepted2 = _slicedToArray$1(_fileAccepted, 1), accepted = _fileAccepted2[0]; 168 var _fileMatchSize = fileMatchSize(file, minSize, maxSize), _fileMatchSize2 = _slicedToArray$1(_fileMatchSize, 1), sizeMatch = _fileMatchSize2[0]; 169 var customErrors = validator ? validator(file) : null; 170 return accepted && sizeMatch && !customErrors; 171 }); 172} 173function isPropagationStopped(event) { 174 if (typeof event.isPropagationStopped === "function") { 175 return event.isPropagationStopped(); 176 } else if (typeof event.cancelBubble !== "undefined") { 177 return event.cancelBubble; 178 } 179 return false; 180} 181function isEvtWithFiles(event) { 182 if (!event.dataTransfer) { 183 return !!event.target && !!event.target.files; 184 } 185 return Array.prototype.some.call(event.dataTransfer.types, function(type) { 186 return type === "Files" || type === "application/x-moz-file"; 187 }); 188} 189function onDocumentDragOver(event) { 190 event.preventDefault(); 191} 192function isIe(userAgent) { 193 return userAgent.indexOf("MSIE") !== -1 || userAgent.indexOf("Trident/") !== -1; 194} 195function isEdge(userAgent) { 196 return userAgent.indexOf("Edge/") !== -1; 197} 198function isIeOrEdge() { 199 var userAgent = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : window.navigator.userAgent; 200 return isIe(userAgent) || isEdge(userAgent); 201} 202function composeEventHandlers() { 203 for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) { 204 fns[_key] = arguments[_key]; 205 } 206 return function(event) { 207 for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 208 args[_key2 - 1] = arguments[_key2]; 209 } 210 return fns.some(function(fn) { 211 if (!isPropagationStopped(event) && fn) { 212 fn.apply(void 0, [event].concat(args)); 213 } 214 return isPropagationStopped(event); 215 }); 216 }; 217} 218function canUseFileSystemAccessAPI() { 219 return "showOpenFilePicker" in window; 220} 221function pickerOptionsFromAccept(accept) { 222 if (isDefined(accept)) { 223 var acceptForPicker = Object.entries(accept).filter(function(_ref2) { 224 var _ref3 = _slicedToArray$1(_ref2, 2), mimeType = _ref3[0], ext = _ref3[1]; 225 var ok = true; 226 if (!isMIMEType(mimeType)) { 227 ok = false; 228 } 229 if (!Array.isArray(ext) || !ext.every(isExt)) { 230 ok = false; 231 } 232 return ok; 233 }).reduce(function(agg, _ref4) { 234 var _ref5 = _slicedToArray$1(_ref4, 2), mimeType = _ref5[0], ext = _ref5[1]; 235 return _objectSpread$1(_objectSpread$1({}, agg), {}, _defineProperty$1({}, mimeType, ext)); 236 }, {}); 237 return [{ 238 // description is required due to https://crbug.com/1264708 239 description: "Files", 240 accept: acceptForPicker 241 }]; 242 } 243 return accept; 244} 245function acceptPropAsAcceptAttr(accept) { 246 if (isDefined(accept)) { 247 return Object.entries(accept).reduce(function(a, _ref6) { 248 var _ref7 = _slicedToArray$1(_ref6, 2), mimeType = _ref7[0], ext = _ref7[1]; 249 return [].concat(_toConsumableArray$1(a), [mimeType], _toConsumableArray$1(ext)); 250 }, []).filter(function(v) { 251 return isMIMEType(v) || isExt(v); 252 }).join(","); 253 } 254 return void 0; 255} 256function isAbort(v) { 257 return v instanceof DOMException && (v.name === "AbortError" || v.code === v.ABORT_ERR); 258} 259function isSecurityError(v) { 260 return v instanceof DOMException && (v.name === "SecurityError" || v.code === v.SECURITY_ERR); 261} 262function isMIMEType(v) { 263 return v === "audio/*" || v === "video/*" || v === "image/*" || v === "text/*" || v === "application/*" || /\w+\/[-+.\w]+/g.test(v); 264} 265function isExt(v) { 266 return /^.*\.[\w]+$/.test(v); 267} 268var _excluded = ["children"], _excluded2 = ["open"], _excluded3 = ["refKey", "role", "onKeyDown", "onFocus", "onBlur", "onClick", "onDragEnter", "onDragOver", "onDragLeave", "onDrop"], _excluded4 = ["refKey", "onChange", "onClick"]; 269function _toConsumableArray(arr) { 270 return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); 271} 272function _nonIterableSpread() { 273 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 274} 275function _iterableToArray(iter) { 276 if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) 277 return Array.from(iter); 278} 279function _arrayWithoutHoles(arr) { 280 if (Array.isArray(arr)) 281 return _arrayLikeToArray(arr); 282} 283function _slicedToArray(arr, i) { 284 return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); 285} 286function _nonIterableRest() {
vendor: 5,276 bytes, lines 287-446
287 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 288} 289function _unsupportedIterableToArray(o, minLen) { 290 if (!o) 291 return; 292 if (typeof o === "string") 293 return _arrayLikeToArray(o, minLen); 294 var n = Object.prototype.toString.call(o).slice(8, -1); 295 if (n === "Object" && o.constructor) 296 n = o.constructor.name; 297 if (n === "Map" || n === "Set") 298 return Array.from(o); 299 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) 300 return _arrayLikeToArray(o, minLen); 301} 302function _arrayLikeToArray(arr, len) { 303 if (len == null || len > arr.length) 304 len = arr.length; 305 for (var i = 0, arr2 = new Array(len); i < len; i++) { 306 arr2[i] = arr[i]; 307 } 308 return arr2; 309} 310function _iterableToArrayLimit(arr, i) { 311 var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; 312 if (_i == null) 313 return; 314 var _arr = []; 315 var _n = true; 316 var _d = false; 317 var _s, _e; 318 try { 319 for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { 320 _arr.push(_s.value); 321 if (i && _arr.length === i) 322 break; 323 } 324 } catch (err) { 325 _d = true; 326 _e = err; 327 } finally { 328 try { 329 if (!_n && _i["return"] != null) 330 _i["return"](); 331 } finally { 332 if (_d) 333 throw _e; 334 } 335 } 336 return _arr; 337} 338function _arrayWithHoles(arr) { 339 if (Array.isArray(arr)) 340 return arr; 341} 342function ownKeys(object, enumerableOnly) { 343 var keys = Object.keys(object); 344 if (Object.getOwnPropertySymbols) { 345 var symbols = Object.getOwnPropertySymbols(object); 346 enumerableOnly && (symbols = symbols.filter(function(sym) { 347 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 348 })), keys.push.apply(keys, symbols); 349 } 350 return keys; 351} 352function _objectSpread(target) { 353 for (var i = 1; i < arguments.length; i++) { 354 var source = null != arguments[i] ? arguments[i] : {}; 355 i % 2 ? ownKeys(Object(source), true).forEach(function(key) { 356 _defineProperty(target, key, source[key]); 357 }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) { 358 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 359 }); 360 } 361 return target; 362} 363function _defineProperty(obj, key, value) { 364 if (key in obj) { 365 Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); 366 } else { 367 obj[key] = value; 368 } 369 return obj; 370} 371function _objectWithoutProperties(source, excluded) { 372 if (source == null) 373 return {}; 374 var target = _objectWithoutPropertiesLoose(source, excluded); 375 var key, i; 376 if (Object.getOwnPropertySymbols) { 377 var sourceSymbolKeys = Object.getOwnPropertySymbols(source); 378 for (i = 0; i < sourceSymbolKeys.length; i++) { 379 key = sourceSymbolKeys[i]; 380 if (excluded.indexOf(key) >= 0) 381 continue; 382 if (!Object.prototype.propertyIsEnumerable.call(source, key)) 383 continue; 384 target[key] = source[key]; 385 } 386 } 387 return target; 388} 389function _objectWithoutPropertiesLoose(source, excluded) { 390 if (source == null) 391 return {}; 392 var target = {}; 393 var sourceKeys = Object.keys(source); 394 var key, i; 395 for (i = 0; i < sourceKeys.length; i++) { 396 key = sourceKeys[i]; 397 if (excluded.indexOf(key) >= 0) 398 continue; 399 target[key] = source[key]; 400 } 401 return target; 402} 403var Dropzone = /* @__PURE__ */ reactExports.forwardRef(function(_ref, ref) { 404 var children = _ref.children, params = _objectWithoutProperties(_ref, _excluded); 405 var _useDropzone = useDropzone(params), open = _useDropzone.open, props = _objectWithoutProperties(_useDropzone, _excluded2); 406 reactExports.useImperativeHandle(ref, function() { 407 return { 408 open 409 }; 410 }, [open]); 411 return /* @__PURE__ */ React.createElement(reactExports.Fragment, null, children(_objectSpread(_objectSpread({}, props), {}, { 412 open 413 }))); 414}); 415Dropzone.displayName = "Dropzone"; 416var defaultProps = { 417 disabled: false, 418 getFilesFromEvent: fromEvent, 419 maxSize: Infinity, 420 minSize: 0, 421 multiple: true, 422 maxFiles: 0, 423 preventDropOnDocument: true, 424 noClick: false, 425 noKeyboard: false, 426 noDrag: false, 427 noDragEventsBubbling: false, 428 validator: null, 429 useFsAccessApi: false, 430 autoFocus: false 431}; 432Dropzone.defaultProps = defaultProps; 433Dropzone.propTypes = { 434 /** 435 * Render function that exposes the dropzone state and prop getter fns 436 * 437 * @param {object} params 438 * @param {Function} params.getRootProps Returns the props you should apply to the root drop container you render 439 * @param {Function} params.getInputProps Returns the props you should apply to hidden file input you render 440 * @param {Function} params.open Open the native file selection dialog 441 * @param {boolean} params.isFocused Dropzone area is in focus 442 * @param {boolean} params.isFileDialogActive File dialog is opened 443 * @param {boolean} params.isDragActive Active drag is in progress 444 * @param {boolean} params.isDragAccept Dragged files are accepted 445 * @param {boolean} params.isDragReject Some dragged files are rejected 446 * @param {boolean}
446 params.isDragGlobal Files are being dragged anywhere on the document 447 * @param {File[]} params.acceptedFiles Accepted files 448 * @param {FileRejection[]} params.fileRejections Rejected files and why they were rejected 449 */ 450 children: PropTypes.func, 451 /** 452 * Set accepted file types. 453 * Checkout https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker types option for more information. 454 * Keep in mind that mime type determination is not reliable across platforms. CSV files, 455 * for example, are reported as text/plain under macOS but as application/vnd.ms-excel under 456 * Windows. In some cases there might not be a mime type set at all (https://github.com/react-dropzone/react-dropzone/issues/276). 457 */ 458 accept: PropTypes.objectOf(PropTypes.arrayOf(PropTypes.string)), 459 /** 460 * Allow drag 'n' drop (or selection from the file dialog) of multiple files 461 */ 462 multiple: PropTypes.bool, 463 /** 464 * If false, allow dropped items to take over the current browser window 465 */ 466 preventDropOnDocument: PropTypes.bool, 467 /** 468 * If true, disables click to open the native file selection dialog 469 */ 470 noClick: PropTypes.bool, 471 /** 472 * If true, disables SPACE/ENTER to open the native file selection dialog. 473 * Note that it also stops tracking the focus state. 474 */ 475 noKeyboard: PropTypes.bool, 476 /** 477 * If true, disables drag 'n' drop 478 */ 479 noDrag: PropTypes.bool, 480 /** 481 * If true, stops drag event propagation to parents 482 */ 483 noDragEventsBubbling: PropTypes.bool, 484 /** 485 * Minimum file size (in bytes) 486 */ 487 minSize: PropTypes.number, 488 /** 489 * Maximum file size (in bytes) 490 */ 491 maxSize: PropTypes.number, 492 /** 493 * Maximum accepted number of files 494 * The default value is 0 which means there is no limitation to how many files are accepted. 495 */ 496 maxFiles: PropTypes.number, 497 /** 498 * Enable/disable the dropzone 499 */ 500 disabled: PropTypes.bool, 501 /** 502 * Use this to provide a custom file aggregator 503 * 504 * @param {(DragEvent|Event|Array<FileSystemFileHandle>)} event A drag event or input change event (if files were selected via the file dialog) 505 */ 506 getFilesFromEvent: PropTypes.func, 507 /** 508 * Cb for when closing the file dialog with no selection 509 */ 510 onFileDialogCancel: PropTypes.func, 511 /** 512 * Cb for when opening the file dialog 513 */ 514 onFileDialogOpen: PropTypes.func, 515 /** 516 * Set to true to use the https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API 517 * to open the file picker instead of using an `<input type="file">` click event. 518 */ 519 useFsAccessApi: PropTypes.bool, 520 /** 521 * Set to true to focus the root element on render 522 */ 523 autoFocus: PropTypes.bool, 524 /** 525 * Cb for when the `dragenter` event occurs. 526 * 527 * @param {DragEvent} event 528 */ 529 onDragEnter: PropTypes.func, 530 /** 531 * Cb for when the `dragleave` event occurs 532 * 533 * @param {DragEvent} event 534 */ 535 onDragLeave: PropTypes.func, 536 /** 537 * Cb for when the `dragover` event occurs 538 * 539 * @param {DragEvent} event 540 */ 541 onDragOver: PropTypes.func, 542 /** 543 * Cb for when the `drop` event occurs. 544 * Note that this callback is invoked after the `getFilesFromEvent` callback is done. 545 * 546 * Files are accepted or rejected based on the `accept`, `multiple`, `minSize` and `maxSize` props. 547 * `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. 548 * If `multiple` is set to false and additional files are dropped, 549 * all files besides the first will be rejected. 550 * Any file which does not have a size in the [`minSize`, `maxSize`] range, will be rejected as well. 551 * 552 * Note that the `onDrop` callback will always be invoked regardless if the dropped files were accepted or rejected. 553 * If you'd like to react to a specific scenario, use the `onDropAccepted`/`onDropRejected` props. 554 * 555 * `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
555server. 556 * For example, with [SuperAgent](https://github.com/visionmedia/superagent) as a http/ajax library: 557 * 558 * ```js 559 * function onDrop(acceptedFiles) { 560 * const req = request.post('/upload') 561 * acceptedFiles.forEach(file => { 562 * req.attach(file.name, file) 563 * }) 564 * req.end(callback) 565 * } 566 * ``` 567 * 568 * @param {File[]} acceptedFiles 569 * @param {FileRejection[]} fileRejections 570 * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog) 571 */ 572 onDrop: PropTypes.func, 573 /** 574 * Cb for when the `drop` event occurs. 575 * Note that if no files are accepted, this callback is not invoked. 576 * 577 * @param {File[]} files 578 * @param {(DragEvent|Event)} event 579 */ 580 onDropAccepted: PropTypes.func, 581 /** 582 * Cb for when the `drop` event occurs. 583 * Note that if no files are rejected, this callback is not invoked. 584 * 585 * @param {FileRejection[]} fileRejections 586 * @param {(DragEvent|Event)} event 587 */ 588 onDropRejected: PropTypes.func, 589 /** 590 * Cb for when there's some error from any of the promises. 591 * 592 * @param {Error} error 593 */ 594 onError: PropTypes.func, 595 /** 596 * Custom validation function. It must return null if there's no errors. 597 * @param {File} file 598 * @returns {FileError|FileError[]|null} 599 */ 600 validator: PropTypes.func 601}; 602var initialState = { 603 isFocused: false, 604 isFileDialogActive: false, 605 isDragActive: false, 606 isDragAccept: false, 607 isDragReject: false, 608 isDragGlobal: false, 609 acceptedFiles: [], 610 fileRejections: [] 611}; 612function useDropzone() { 613 var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; 614 var _defaultProps$props = _objectSpread(_objectSpread({}, defaultProps), props), accept = _defaultProps$props.accept, disabled = _defaultProps$props.disabled, getFilesFromEvent = _defaultProps$props.getFilesFromEvent, maxSize = _defaultProps$props.maxSize, minSize = _defaultProps$props.minSize, multiple = _defaultProps$props.multiple, maxFiles = _defaultProps$props.maxFiles, onDragEnter = _defaultProps$props.onDragEnter, onDragLeave = _defaultProps$props.onDragLeave, onDragOver = _defaultProps$props.onDragOver, onDrop = _defaultProps$props.onDrop, onDropAccepted = _defaultProps$props.onDropAccepted, onDropRejected = _defaultProps$props.onDropRejected, onFileDialogCancel = _defaultProps$props.onFileDialogCancel, onFileDialogOpen = _defaultProps$props.onFileDialogOpen, useFsAccessApi = _defaultProps$props.useFsAccessApi, autoFocus = _defaultProps$props.autoFocus, preventDropOnDocument = _defaultProps$props.preventDropOnDocument, noClick = _defaultProps$props.noClick, noKeyboard = _defaultProps$props.noKeyboard, noDrag = _defaultProps$props.noDrag, noDragEventsBubbling = _defaultProps$props.noDragEventsBubbling, onError = _defaultProps$props.onError, validator = _defaultProps$props.validator; 615 var acceptAttr = reactExports.useMemo(function() { 616 return acceptPropAsAcceptAttr(accept); 617 }, [accept]); 618 var pickerTypes = reactExports.useMemo(function() { 619 return pickerOptionsFromAccept(accept); 620 }, [accept]); 621 var onFileDialogOpenCb = reactExports.useMemo(function() { 622 return typeof onFileDialogOpen === "function" ? onFileDialogOpen : noop; 623 }, [onFileDialogOpen]); 624 var onFileDialogCancelCb = reactExports.useMemo(function() { 625 return typeof onFileDialogCancel === "function" ? onFileDialogCancel : noop; 626 }, [onFileDialogCancel]); 627 var rootRef = reactExports.useRef(null); 628 var inputRef = reactExports.useRef(null); 629 var _useReducer = reactExports.useReducer(reducer, initialState), _useReducer2 = _slicedToArray(_useReducer, 2), state = _useReducer2[0], dispatch = _useReducer2[1]; 630 var isFocused = state.isFocused, isFileDialogActive = state.isFileDialogActive; 631 var fsAccessApiWorksRef = reactExports.useRef(typeof window !== "undefined" && window.isSecureContext && useFsAccessApi && canUseFileSystemAccessAPI()); 632 var onWindowFocus = function onWindowFocus2() { 633 if (!fsAccessApiWorksRef.current && isFileDialogActive) { 634 setTimeout(function() { 635 if (inputRef.current) { 636 var files = inputRef.current.files; 637 if (!files.length) { 638 dispatch({ 639 type: "closeDialog" 640 }); 641 onFileDialogCancelCb(); 642 } 643 } 644 }, 300); 645 } 646 }; 647 reactExports.useEffect(function() { 648 window.addEventListener("focus", onWindowFocus, false); 649 return function() { 650 window.removeEventListener("focus", onWindowFocus, false); 651 }; 652 }, [inputRef, isFileDialogActive, onFileDialogCancelCb, fsAccessApiWorksRef]); 653 var dragTargetsRef = reactExports.useRef([]); 654 var globalDragTargetsRef = reactExports.useRef([]); 655 var onDocumentDrop = function onDocumentDrop2(event) { 656 if (rootRef.current && rootRef.current.contains(event.target)) { 657 return; 658 } 659 event.preventDefault(); 660 dragTargetsRef.current = []; 661 }; 662 reactExports.useEffect(function() { 663 if (preventDropOnDocument) { 664 document.addEventListener("dragover", onDocumentDragOver, false); 665 document.addEventListener("drop", onDocumentDrop, false); 666 } 667 return function() { 668 if (preventDropOnDocument) { 669 document.removeEventListener("dragover", onDocumentDragOver); 670 document.removeEventListener("drop", onDocumentDrop); 671 } 672 }; 673 }, [rootRef, preventDropOnDocument]); 674 reactExports.useEffect(function() { 675 var onDocumentDragEnter = function onDocumentDragEnter2(event) { 676 globalDragTargetsRef.current = [].concat(_toConsumableArray(globalDragTargetsRef.current), [event.target]); 677 if (isEvtWithFiles(event)) { 678 dispatch({ 679 isDragGlobal: true, 680 type: "setDragGlobal" 681 }); 682 } 683 }; 684 var onDocumentDragLeave = function onDocumentDragLeave2(event) { 685 globalDragTargetsRef.current = globalDragTargetsRef.current.filter(function(el) { 686 return el !== event.target && el !== null; 687 }); 688 if (globalDragTargetsRef.current.length > 0) { 689 return; 690 } 691 dispatch({ 692 isDragGlobal: false, 693 type: "setDragGlobal" 694 }); 695 }; 696 var onDocumentDragEnd = function onDocumentDragEnd2() { 697 globalDragTargetsRef.current = []; 698 dispatch({ 699 isDragGlobal: false, 700 type: "setDragGlobal" 701 }); 702 }; 703 var onDocumentDropGlobal = function onDocumentDropGlobal2() { 704 globalDragTargetsRef.current = []; 705 dispatch({ 706 isDragGlobal: false, 707 type: "setDragGlobal" 708 }); 709 }; 710 document.addEventListener("dragenter", onDocumentDragEnter, false); 711 document.addEventListener("dragleave", onDocumentDragLeave, false); 712 document.addEventListener("dragend", onDocumentDragEnd, false); 713 document.addEventListener("drop", onDocumentDropGlobal, false); 714 return function() { 715 document.removeEventListener("dragenter", onDocumentDragEnter); 716 document.removeEventListener("dragleave", onDocumentDragLeave); 717 document.removeEventListener("dragend", onDocumentDragEnd); 718 document.removeEventListener("drop", onDocumentDropGlobal); 719 }; 720 }, [rootRef]); 721 reactExports.useEffect(function() { 722 if (!disabled && autoFocus && rootRef.current) { 723 rootRef.current.focus(); 724 } 725 return function() { 726 }; 727 }, [rootRef, autoFocus, disabled]); 728 var onErrCb = reactExports.useCallback(function(e) { 729 if (onError) { 730 onError(e); 731 } else { 732 } 733 }, [onError]); 734 var onDragEnterCb = reactExports.useCallback(function(event) { 735 event.preventDefault(); 736 event.persist(); 737 stopPropagation(event); 738 dragTargetsRef.current = [].concat(_toConsumableArray(dragTargetsRef.current), [event.target]); 739 if (isEvtWithFiles(event)) { 740 Promise.resolve(getFilesFromEvent(event)).then(function(files) { 741 if (isPropagationStopped(event) && !noDragEventsBubbling) { 742 return; 743 } 744 var fileCount = files.length; 745 var isDragAccept = fileCount > 0 && allFilesAccepted({ 746 files, 747 accept: acceptAttr, 748 minSize, 749 maxSize, 750 multiple, 751 maxFiles, 752 validator 753 }); 754 var isDragReject = fileCount > 0 && !isDragAccept; 755 dispatch({ 756 isDragAccept, 757 isDragReject, 758 isDragActive: true, 759 type: "setDraggedFiles" 760 }); 761 if (onDragEnter) { 762 onDragEnter(event); 763 } 764 }).catch(function(e) { 765 return onErrCb(e); 766 }); 767 } 768 }, [getFilesFromEvent, onDragEnter, onErrCb, noDragEventsBubbling, acceptAttr, minSize, maxSize, multiple, maxFiles, validator]); 769 var onDragOverCb = reactExports.useCallback(function(event) { 770 event.preventDefault(); 771 event.persist(); 772 stopPropagation(event); 773 var hasFiles = isEvtWithFiles(event); 774 if (hasFiles && event.dataTransfer) {
775 try { 776 event.dataTransfer.dropEffect = "copy"; 777 } catch (_unused) { 778 } 779 } 780 if (hasFiles && onDragOver) { 781 onDragOver(event); 782 } 783 return false; 784 }, [onDragOver, noDragEventsBubbling]); 785 var onDragLeaveCb = reactExports.useCallback(function(event) { 786 event.preventDefault(); 787 event.persist(); 788 stopPropagation(event); 789 var targets = dragTargetsRef.current.filter(function(target) { 790 return rootRef.current && rootRef.current.contains(target); 791 }); 792 var targetIdx = targets.indexOf(event.target); 793 if (targetIdx !== -1) { 794 targets.splice(targetIdx, 1); 795 } 796 dragTargetsRef.current = targets; 797 if (targets.length > 0) { 798 return; 799 } 800 dispatch({ 801 type: "setDraggedFiles", 802 isDragActive: false, 803 isDragAccept: false, 804 isDragReject: false 805 }); 806 if (isEvtWithFiles(event) && onDragLeave) { 807 onDragLeave(event); 808 } 809 }, [rootRef, onDragLeave, noDragEventsBubbling]); 810 var setFiles = reactExports.useCallback(function(files, event) { 811 var acceptedFiles = []; 812 var fileRejections = []; 813 files.forEach(function(file) { 814 var _fileAccepted = fileAccepted(file, acceptAttr), _fileAccepted2 = _slicedToArray(_fileAccepted, 2), accepted = _fileAccepted2[0], acceptError = _fileAccepted2[1]; 815 var _fileMatchSize = fileMatchSize(file, minSize, maxSize), _fileMatchSize2 = _slicedToArray(_fileMatchSize, 2), sizeMatch = _fileMatchSize2[0], sizeError = _fileMatchSize2[1]; 816 var customErrors = validator ? validator(file) : null; 817 if (accepted && sizeMatch && !customErrors) { 818 acceptedFiles.push(file); 819 } else { 820 var errors = [acceptError, sizeError]; 821 if (customErrors) { 822 errors = errors.concat(customErrors); 823 } 824 fileRejections.push({ 825 file, 826 errors: errors.filter(function(e) { 827 return e; 828 }) 829 }); 830 } 831 }); 832 if (!multiple && acceptedFiles.length > 1 || multiple && maxFiles >= 1 && acceptedFiles.length > maxFiles) { 833 acceptedFiles.forEach(function(file) { 834 fileRejections.push({ 835 file, 836 errors: [TOO_MANY_FILES_REJECTION] 837 }); 838 }); 839 acceptedFiles.splice(0); 840 } 841 dispatch({ 842 acceptedFiles, 843 fileRejections, 844 isDragReject: fileRejections.length > 0, 845 type: "setFiles" 846 }); 847 if (onDrop) { 848 onDrop(acceptedFiles, fileRejections, event); 849 } 850 if (fileRejections.length > 0 && onDropRejected) { 851 onDropRejected(fileRejections, event); 852 } 853 if (acceptedFiles.length > 0 && onDropAccepted) { 854 onDropAccepted(acceptedFiles, event); 855 } 856 }, [dispatch, multiple, acceptAttr, minSize, maxSize, maxFiles, onDrop, onDropAccepted, onDropRejected, validator]); 857 var onDropCb = reactExports.useCallback(function(event) { 858 event.preventDefault(); 859 event.persist(); 860 stopPropagation(event); 861 dragTargetsRef.current = []; 862 if (isEvtWithFiles(event)) { 863 Promise.resolve(getFilesFromEvent(event)).then(function(files) { 864 if (isPropagationStopped(event) && !noDragEventsBubbling) { 865 return; 866 } 867 setFiles(files, event); 868 }).catch(function(e) { 869 return onErrCb(e); 870 }); 871 } 872 dispatch({ 873 type: "reset" 874 }); 875 }, [getFilesFromEvent, setFiles, onErrCb, noDragEventsBubbling]); 876 var openFileDialog = reactExports.useCallback(function() { 877 if (fsAccessApiWorksRef.current) { 878 dispatch({ 879 type: "openDialog" 880 }); 881 onFileDialogOpenCb(); 882 var opts = { 883 multiple, 884 types: pickerTypes 885 }; 886 window.showOpenFilePicker(opts).then(function(handles) { 887 return getFilesFromEvent(handles); 888 }).then(function(files) { 889 setFiles(files, null); 890 dispatch({ 891 type: "closeDialog" 892 }); 893 }).catch(function(e) { 894 if (isAbort(e)) { 895 onFileDialogCancelCb(e); 896 dispatch({ 897 type: "closeDialog" 898 }); 899 } else if (isSecurityError(e)) { 900 fsAccessApiWorksRef.current = false;
901 if (inputRef.current) { 902 inputRef.current.value = null; 903 inputRef.current.click(); 904 } else { 905 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.")); 906 } 907 } else { 908 onErrCb(e); 909 } 910 }); 911 return; 912 } 913 if (inputRef.current) { 914 dispatch({ 915 type: "openDialog" 916 }); 917 onFileDialogOpenCb(); 918 inputRef.current.value = null; 919 inputRef.current.click(); 920 } 921 }, [dispatch, onFileDialogOpenCb, onFileDialogCancelCb, useFsAccessApi, setFiles, onErrCb, pickerTypes, multiple]); 922 var onKeyDownCb = reactExports.useCallback(function(event) { 923 if (!rootRef.current || !rootRef.current.isEqualNode(event.target)) { 924 return; 925 } 926 if (event.key === " " || event.key === "Enter" || event.keyCode === 32 || event.keyCode === 13) { 927 event.preventDefault(); 928 openFileDialog(); 929 } 930 }, [rootRef, openFileDialog]); 931 var onFocusCb = reactExports.useCallback(function() { 932 dispatch({ 933 type: "focus" 934 }); 935 }, []); 936 var onBlurCb = reactExports.useCallback(function() { 937 dispatch({ 938 type: "blur" 939 }); 940 }, []); 941 var onClickCb = reactExports.useCallback(function() { 942 if (noClick) { 943 return; 944 } 945 if (isIeOrEdge()) { 946 setTimeout(openFileDialog, 0); 947 } else { 948 openFileDialog(); 949 } 950 }, [noClick, openFileDialog]); 951 var composeHandler = function composeHandler2(fn) { 952 return disabled ? null : fn; 953 }; 954 var composeKeyboardHandler = function composeKeyboardHandler2(fn) { 955 return noKeyboard ? null : composeHandler(fn); 956 }; 957 var composeDragHandler = function composeDragHandler2(fn) { 958 return noDrag ? null : composeHandler(fn); 959 }; 960 var stopPropagation = function stopPropagation2(event) { 961 if (noDragEventsBubbling) { 962 event.stopPropagation(); 963 } 964 }; 965 var getRootProps = reactExports.useMemo(function() { 966 return function() { 967 var _ref2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref2$refKey = _ref2.refKey, refKey = _ref2$refKey === void 0 ? "ref" : _ref2$refKey, role = _ref2.role, onKeyDown = _ref2.onKeyDown, onFocus = _ref2.onFocus, onBlur = _ref2.onBlur, onClick = _ref2.onClick, onDragEnter2 = _ref2.onDragEnter, onDragOver2 = _ref2.onDragOver, onDragLeave2 = _ref2.onDragLeave, onDrop2 = _ref2.onDrop, rest = _objectWithoutProperties(_ref2, _excluded3); 968 return _objectSpread(_objectSpread(_defineProperty({ 969 onKeyDown: composeKeyboardHandler(composeEventHandlers(onKeyDown, onKeyDownCb)), 970 onFocus: composeKeyboardHandler(composeEventHandlers(onFocus, onFocusCb)), 971 onBlur: composeKeyboardHandler(composeEventHandlers(onBlur, onBlurCb)), 972 onClick: composeHandler(composeEventHandlers(onClick, onClickCb)), 973 onDragEnter: composeDragHandler(composeEventHandlers(onDragEnter2, onDragEnterCb)), 974 onDragOver: composeDragHandler(composeEventHandlers(onDragOver2, onDragOverCb)), 975 onDragLeave: composeDragHandler(composeEventHandlers(onDragLeave2, onDragLeaveCb)), 976 onDrop: composeDragHandler(composeEventHandlers(onDrop2, onDropCb)), 977 role: typeof role === "string" && role !== "" ? role : "presentation" 978 }, refKey, rootRef), !disabled && !noKeyboard ? { 979 tabIndex: 0 980 } : {}), rest); 981 }; 982 }, [rootRef, onKeyDownCb, onFocusCb, onBlurCb, onClickCb, onDragEnterCb, onDragOverCb, onDragLeaveCb, onDropCb, noKeyboard, noDrag, disabled]); 983 var onInputElementClick = reactExports.useCallback(function(event) { 984 event.stopPropagation(); 985 }, []); 986 var getInputProps = reactExports.useMemo(function() { 987 return function() { 988 var _ref3 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref3$refKey = _ref3.refKey, refKey = _ref3$refKey === void 0 ? "ref" : _ref3$refKey, onChange = _ref3.onChange, onClick = _ref3.onClick, rest = _objectWithoutProperties(_ref3, _excluded4); 989 var inputProps = _defineProperty({ 990 accept: acceptAttr, 991 multiple, 992 type: "file", 993 style: { 994 border: 0, 995 clip: "rect(0, 0, 0, 0)", 996 clipPath: "inset(50%)", 997 height: "1px", 998 margin: "0 -1px -1px 0", 999 overflow: "hidden", 1000 padding: 0, 1001 position: "absolute", 1002 width: "1px", 1003 whiteSpace: "nowrap" 1004 }, 1005 onChange: composeHandler(composeEventHandlers(onChange, onDropCb)), 1006 onClick: composeHandler(composeEventHandlers(onClick, onInputElementClick)), 1007 tabIndex: -1 1008 }, refKey, inputRef); 1009 return _objectSpread(_objectSpread({}, inputProps), rest); 1010 }; 1011 }, [inputRef, accept, multiple, onDropCb, disabled]); 1012 return _objectSpread(_objectSpread({}, state), {}, { 1013 isFocused: isFocused && !disabled, 1014 getRootProps, 1015 getInputProps, 1016 rootRef, 1017 inputRef, 1018 open: composeHandler(openFileDialog) 1019 }); 1020} 1021function reducer(state, action) { 1022 switch (action.type) { 1023 case "focus": 1024 return _objectSpread(_objectSpread({}, state), {}, { 1025 isFocused: true 1026 }); 1027 case "blur": 1028 return _objectSpread(_objectSpread({}, state), {}, { 1029 isFocused: false 1030 }); 1031 case "openDialog": 1032 return _objectSpread(_objectSpread({}, initialState), {}, { 1033 isFileDialogActive: true 1034 }); 1035 case "closeDialog": 1036 return _objectSpread(_objectSpread({}, state), {}, { 1037 isFileDialogActive: false 1038 }); 1039 case "setDraggedFiles": 1040 return _objectSpread(_objectSpread({}, state), {}, { 1041 isDragActive: action.isDragActive, 1042 isDragAccept: action.isDragAccept, 1043 isDragReject: action.isDragReject 1044 }); 1045 case "setFiles": 1046 return _objectSpread(_objectSpread({}, state), {}, { 1047 acceptedFiles: action.acceptedFiles, 1048 fileRejections: action.fileRejections, 1049 isDragReject: action.isDragReject 1050 }); 1051 case "setDragGlobal": 1052 return _objectSpread(_objectSpread({}, state), {}, { 1053 isDragGlobal: action.isDragGlobal 1054 }); 1055 case "reset": 1056 return _objectSpread({}, initialState); 1057 default: 1058 return state; 1059 } 1060} 1061function noop() { 1062} 1063export { 1064 useDropzone as u 1065};
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.