├── .gitignore
├── .npmignore
├── test
    └── basic.js
├── .github
    ├── dependabot.yml
    └── workflows
    │   └── ci.yml
├── buffer.js
├── LICENSE
├── example
    └── index.html
├── package.json
├── README.md
└── index.js


/.gitignore:
--------------------------------------------------------------------------------
1 | example/drag-drop.js
2 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .github/
2 | example/
3 | test/
4 | 


--------------------------------------------------------------------------------
/test/basic.js:
--------------------------------------------------------------------------------
 1 | const test = require('tape')
 2 | 
 3 | // writing tests for this would be hard, so let's just check that requiring the module
 4 | // doesn't throw
 5 | 
 6 | test('requiring drag-drop does not throw', t => {
 7 |   t.doesNotThrow(() => {
 8 |     require('../')
 9 |   })
10 |   t.end()
11 | })
12 | 


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | updates:
 3 |   - package-ecosystem: npm
 4 |     directory: /
 5 |     schedule:
 6 |       interval: daily
 7 |     labels:
 8 |       - dependency
 9 |     versioning-strategy: increase-if-necessary
10 |   - package-ecosystem: github-actions
11 |     directory: /
12 |     schedule:
13 |       interval: daily
14 |     labels:
15 |       - dependency
16 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: ci
 2 | 'on':
 3 |   - push
 4 |   - pull_request
 5 | jobs:
 6 |   test:
 7 |     name: Node ${{ matrix.node }} / ${{ matrix.os }}
 8 |     runs-on: ${{ matrix.os }}
 9 |     strategy:
10 |       fail-fast: false
11 |       matrix:
12 |         os:
13 |           - ubuntu-latest
14 |         node:
15 |           - '14'
16 |     steps:
17 |       - uses: actions/checkout@v2
18 |       - uses: actions/setup-node@v2
19 |         with:
20 |           node-version: ${{ matrix.node }}
21 |       - run: npm install
22 |       - run: npm run build --if-present
23 |       - run: npm test
24 | 


--------------------------------------------------------------------------------
/buffer.js:
--------------------------------------------------------------------------------
 1 | module.exports = dragDropAsBuffer
 2 | 
 3 | const dragDrop = require('./')
 4 | const parallel = require('run-parallel')
 5 | const blobToBuffer = require('blob-to-buffer')
 6 | 
 7 | function dragDropAsBuffer (elem, cb) {
 8 |   return dragDrop(elem, function (files, pos, fileList) {
 9 |     const tasks = files.map(function (file) {
10 |       return function (cb) {
11 |         blobToBuffer(file, function (err, buffer) {
12 |           if (err) return cb(err)
13 |           buffer.name = file.name
14 |           buffer.fullPath = file.fullPath
15 |           buffer.size = file.size
16 |           buffer.type = file.type
17 |           buffer.lastModifiedDate = file.lastModifiedDate
18 |           cb(null, buffer)
19 |         })
20 |       }
21 |     })
22 |     parallel(tasks, function (err, results) {
23 |       if (err) throw err
24 |       cb(results, pos, fileList)
25 |     })
26 |   })
27 | }
28 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) Feross Aboukhadijeh
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/example/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <title>drag-drop example</title>
 4 |     <style>
 5 |       body {
 6 |         height: 100%;
 7 |       }
 8 |       .drag {
 9 |         border: 5px solid red;
10 |       }
11 |     </style>
12 |   </head>
13 |   <body>
14 |     <h1>Drag something onto this page</h1>
15 |     <script src="drag-drop.js"></script>
16 |     <script>
17 |       window.remove = DragDrop('body', {
18 |         onDrop: function (files, pos, fileList, directories) {
19 |           window.files = files
20 |           console.log('onDrop: ' + files.length + ' files at ' + pos.x + ', ' + pos.y)
21 |           files.forEach(function (file) {
22 |             console.log('- ' + file.name + ' (' + file.size + ') (' + file.type + ')')
23 |           })
24 |           console.log('files array', files)
25 |           console.log('FileList object', fileList)
26 |           console.log('directories array', directories)
27 |         },
28 |         onDropText: function (text, pos) {
29 |           window.text = text
30 |           console.log('onDropText: ' + text + ' at ' + pos.x + ', ' + pos.y)
31 |         }
32 |       })
33 |     </script>
34 |   </body>
35 | </html>
36 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "drag-drop",
 3 |   "description": "HTML5 drag & drop for humans",
 4 |   "version": "7.2.0",
 5 |   "author": {
 6 |     "name": "Feross Aboukhadijeh",
 7 |     "email": "feross@feross.org",
 8 |     "url": "https://feross.org"
 9 |   },
10 |   "bugs": {
11 |     "url": "https://github.com/feross/drag-drop/issues"
12 |   },
13 |   "dependencies": {
14 |     "blob-to-buffer": "^1.2.9",
15 |     "run-parallel": "^1.2.0"
16 |   },
17 |   "devDependencies": {
18 |     "babel-minify": "^0.5.1",
19 |     "browserify": "^17.0.0",
20 |     "ecstatic": "^4.1.4",
21 |     "standard": "*",
22 |     "tape": "^5.2.2"
23 |   },
24 |   "homepage": "https://github.com/feross/drag-drop",
25 |   "keywords": [
26 |     "drag",
27 |     "drop",
28 |     "dnd",
29 |     "drag and drop",
30 |     "drag drop",
31 |     "html5",
32 |     "drag & drop",
33 |     "frontend",
34 |     "browserify"
35 |   ],
36 |   "license": "MIT",
37 |   "main": "index.js",
38 |   "repository": {
39 |     "type": "git",
40 |     "url": "git://github.com/feross/drag-drop.git"
41 |   },
42 |   "scripts": {
43 |     "example": "browserify -s DragDrop -r . > example/drag-drop.js && ecstatic example --port 4000",
44 |     "size": "browserify -s DragDrop -r . | minify | gzip | wc -c",
45 |     "test": "standard && tape test/*.js"
46 |   },
47 |   "funding": [
48 |     {
49 |       "type": "github",
50 |       "url": "https://github.com/sponsors/feross"
51 |     },
52 |     {
53 |       "type": "patreon",
54 |       "url": "https://www.patreon.com/feross"
55 |     },
56 |     {
57 |       "type": "consulting",
58 |       "url": "https://feross.org/support"
59 |     }
60 |   ]
61 | }
62 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # drag-drop [![ci][ci-image]][ci-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
  2 | 
  3 | [ci-image]: https://img.shields.io/github/workflow/status/feross/drag-drop/ci/master
  4 | [ci-url]: https://github.com/feross/drag-drop/actions
  5 | [npm-image]: https://img.shields.io/npm/v/drag-drop.svg
  6 | [npm-url]: https://npmjs.org/package/drag-drop
  7 | [downloads-image]: https://img.shields.io/npm/dm/drag-drop.svg
  8 | [downloads-url]: https://npmjs.org/package/drag-drop
  9 | [standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
 10 | [standard-url]: https://standardjs.com
 11 | 
 12 | ### HTML5 drag & drop for humans
 13 | 
 14 | In case you didn't know, the
 15 | [HTML5 drag and drop API](https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API)
 16 | is a
 17 | [total disaster](http://www.quirksmode.org/blog/archives/2009/09/the_html5_drag.html)!
 18 | This is an attempt to make the API usable by mere mortals.
 19 | 
 20 | ### live demo
 21 | 
 22 | See [https://instant.io](https://instant.io).
 23 | 
 24 | ### features
 25 | 
 26 | - simple API
 27 | - supports files and directories
 28 | - excellent browser support (Chrome, Firefox, Safari, Edge)
 29 | - adds a `drag` class to the drop target on hover, for easy styling!
 30 | - optionally, get the file(s) as a Buffer (see [buffer](https://github.com/feross/buffer))
 31 | 
 32 | ### install
 33 | 
 34 | ```
 35 | npm install drag-drop
 36 | ```
 37 | 
 38 | This package works in the browser with [browserify](https://browserify.org). If you do not use a bundler, you can use the [standalone script](https://bundle.run/drag-drop) directly in a `<script>` tag.
 39 | 
 40 | ### usage
 41 | 
 42 | ```js
 43 | const dragDrop = require('drag-drop')
 44 | 
 45 | dragDrop('#dropTarget', (files, pos, fileList, directories) => {
 46 |   console.log('Here are the dropped files', files) // Array of File objects
 47 |   console.log('Dropped at coordinates', pos.x, pos.y)
 48 |   console.log('Here is the raw FileList object if you need it:', fileList)
 49 |   console.log('Here is the list of directories:', directories)
 50 | })
 51 | ```
 52 | 
 53 | Another handy thing this does is add a `drag` class to the drop target when the user
 54 | is dragging a file over the drop target. Useful for styling the drop target to make
 55 | it obvious that this is a drop target!
 56 | 
 57 | ### complete example
 58 | 
 59 | ```js
 60 | const dragDrop = require('drag-drop')
 61 | 
 62 | // You can pass in a DOM node or a selector string!
 63 | dragDrop('#dropTarget', (files, pos, fileList, directories) => {
 64 |   console.log('Here are the dropped files', files)
 65 |   console.log('Dropped at coordinates', pos.x, pos.y)
 66 |   console.log('Here is the raw FileList object if you need it:', fileList)
 67 |   console.log('Here is the list of directories:', directories)
 68 | 
 69 |   // `files` is an Array!
 70 |   files.forEach(file => {
 71 |     console.log(file.name)
 72 |     console.log(file.size)
 73 |     console.log(file.type)
 74 |     console.log(file.lastModifiedDate)
 75 |     console.log(file.fullPath) // not real full path due to browser security restrictions
 76 |     console.log(file.path) // in Electron, this contains the actual full path
 77 | 
 78 |     // convert the file to a Buffer that we can use!
 79 |     const reader = new FileReader()
 80 |     reader.addEventListener('load', e => {
 81 |       // e.target.result is an ArrayBuffer
 82 |       const arr = new Uint8Array(e.target.result)
 83 |       const buffer = new Buffer(arr)
 84 | 
 85 |       // do something with the buffer!
 86 |     })
 87 |     reader.addEventListener('error', err => {
 88 |       console.error('FileReader error' + err)
 89 |     })
 90 |     reader.readAsArrayBuffer(file)
 91 |   })
 92 | })
 93 | ```
 94 | 
 95 | ### get files as buffers
 96 | 
 97 | If you prefer to access file data as Buffers, then just require drag-drop like this:
 98 | 
 99 | ```js
100 | const dragDrop = require('drag-drop/buffer')
101 | 
102 | dragDrop('#dropTarget', files => {
103 |   files.forEach(file => {
104 |     // file is actually a buffer!
105 |     console.log(file.readUInt32LE(0))
106 |     console.log(file.toJSON())
107 |     console.log(file.toString('hex')) // etc...
108 | 
109 |     // but it still has all the normal file properties!
110 |     console.log(file.name)
111 |     console.log(file.size)
112 |     console.log(file.type)
113 |     console.log(file.lastModifiedDate)
114 |   })
115 | })
116 | ```
117 | 
118 | ### detect drag-and-dropped text
119 | 
120 | If the user highlights text and drags it, we capture that as a separate event.
121 | Listen for it like this:
122 | 
123 | ```js
124 | const dragDrop = require('drag-drop')
125 | 
126 | dragDrop('#dropTarget', {
127 |   onDropText: (text, pos) => {
128 |     console.log('Here is the dropped text:', text)
129 |     console.log('Dropped at coordinates', pos.x, pos.y)
130 |   }
131 | })
132 | ```
133 | 
134 | ### detect `dragenter`, `dragover` and `dragleave` events
135 | 
136 | Instead of passing just an `ondrop` function as the second argument, instead pass an
137 | object with all the events you want to listen for:
138 | 
139 | ```js
140 | const dragDrop = require('drag-drop')
141 | 
142 | dragDrop('#dropTarget', {
143 |   onDrop: (files, pos, fileList, directories) => {
144 |     console.log('Here are the dropped files', files)
145 |     console.log('Dropped at coordinates', pos.x, pos.y)
146 |     console.log('Here is the raw FileList object if you need it:', fileList)
147 |     console.log('Here is the list of directories:', directories)
148 |   },
149 |   onDropText: (text, pos) => {
150 |     console.log('Here is the dropped text:', text)
151 |     console.log('Dropped at coordinates', pos.x, pos.y)
152 |   },
153 |   onDragEnter: (event) => {},
154 |   onDragOver: (event) => {},
155 |   onDragLeave: (event) => {}
156 | })
157 | ```
158 | 
159 | You can rely on the `onDragEnter` and `onDragLeave` events to fire only for the
160 | drop target you specified. Events which bubble up from child nodes are ignored
161 | so that you can expect a single `onDragEnter` and then a single `onDragLeave`
162 | event to fire.
163 | 
164 | Furthermore, neither `onDragEnter`, `onDragLeave`, nor `onDragOver` will fire
165 | for drags which cannot be handled by the registered drop listeners. For example,
166 | if you only listen for `onDrop` (files) but not `onDropText` (text) and the user
167 | is dragging text over the drop target, then none of the listed events will fire.
168 | 
169 | ### remove listeners
170 | 
171 | To stop listening for drag & drop events and remove the event listeners, just use the
172 | `cleanup` function returned by the `dragDrop` function.
173 | 
174 | ```js
175 | const dragDrop = require('drag-drop')
176 | 
177 | const cleanup = dragDrop('#dropTarget', files => {
178 |   // ...
179 | })
180 | 
181 | // ... at some point in the future, stop listening for drag & drop events
182 | cleanup()
183 | ```
184 | 
185 | ### support pasting files from the clipboard
186 | 
187 | To support users pasting files from their clipboard, use the provided
188 | `processItems()` function to process the `DataTransferItemList` from the
189 | browser's native `'paste'` event.
190 | 
191 | ```js
192 | document.addEventListener('paste', event => {
193 |   dragDrop.processItems(event.clipboardData.items, (err, files) => {
194 |     // ...
195 |   })
196 | })
197 | ```
198 | 
199 | ### a note about `file://` urls
200 | 
201 | Don't run your app from `file://`. For security reasons, browsers do not allow you to
202 | run your app from `file://`.  In fact, many of the powerful storage APIs throw errors
203 | if you run the app locally from `file://`.
204 | 
205 | Instead, start a local server and visit your site at `http://localhost:port`.
206 | 
207 | ### license
208 | 
209 | MIT. Copyright (c) [Feross Aboukhadijeh](http://feross.org).
210 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | /*! drag-drop. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
  2 | module.exports = dragDrop
  3 | module.exports.processItems = processItems
  4 | 
  5 | const parallel = require('run-parallel')
  6 | 
  7 | function dragDrop (elem, listeners) {
  8 |   if (typeof elem === 'string') {
  9 |     const selector = elem
 10 |     elem = window.document.querySelector(elem)
 11 |     if (!elem) {
 12 |       throw new Error(`"${selector}" does not match any HTML elements`)
 13 |     }
 14 |   }
 15 | 
 16 |   if (!elem) {
 17 |     throw new Error(`"${elem}" is not a valid HTML element`)
 18 |   }
 19 | 
 20 |   if (typeof listeners === 'function') {
 21 |     listeners = { onDrop: listeners }
 22 |   }
 23 | 
 24 |   elem.addEventListener('dragenter', onDragEnter, false)
 25 |   elem.addEventListener('dragover', onDragOver, false)
 26 |   elem.addEventListener('dragleave', onDragLeave, false)
 27 |   elem.addEventListener('drop', onDrop, false)
 28 | 
 29 |   let isEntered = false
 30 |   let numIgnoredEnters = 0
 31 | 
 32 |   // Function to remove drag-drop listeners
 33 |   return function cleanup () {
 34 |     removeDragClass()
 35 |     elem.removeEventListener('dragenter', onDragEnter, false)
 36 |     elem.removeEventListener('dragover', onDragOver, false)
 37 |     elem.removeEventListener('dragleave', onDragLeave, false)
 38 |     elem.removeEventListener('drop', onDrop, false)
 39 |   }
 40 | 
 41 |   function isEventHandleable (event) {
 42 |     if (event.dataTransfer.items || event.dataTransfer.types) {
 43 |       // Only add "drag" class when `items` contains items that are able to be
 44 |       // handled by the registered listeners (files vs. text)
 45 |       const items = Array.from(event.dataTransfer.items)
 46 |       const types = Array.from(event.dataTransfer.types)
 47 | 
 48 |       let fileItems
 49 |       let textItems
 50 |       if (items.length) {
 51 |         fileItems = items.filter(item => { return item.kind === 'file' })
 52 |         textItems = items.filter(item => { return item.kind === 'string' })
 53 |       } else if (types.length) {
 54 |         // event.dataTransfer.items is empty during 'dragover' in Safari, so use
 55 |         // event.dataTransfer.types as a fallback
 56 |         fileItems = types.filter(item => item === 'Files')
 57 |         textItems = types.filter(item => item.startsWith('text/'))
 58 |       } else {
 59 |         return false
 60 |       }
 61 | 
 62 |       if (fileItems.length === 0 && !listeners.onDropText) return false
 63 |       if (textItems.length === 0 && !listeners.onDrop) return false
 64 |       if (fileItems.length === 0 && textItems.length === 0) return false
 65 | 
 66 |       return true
 67 |     }
 68 |     return false
 69 |   }
 70 | 
 71 |   function onDragEnter (event) {
 72 |     event.stopPropagation()
 73 |     event.preventDefault()
 74 | 
 75 |     if (!isEventHandleable(event)) return
 76 | 
 77 |     if (isEntered) {
 78 |       numIgnoredEnters += 1
 79 |       return false // early return
 80 |     }
 81 | 
 82 |     isEntered = true
 83 | 
 84 |     if (listeners.onDragEnter) {
 85 |       listeners.onDragEnter(event)
 86 |     }
 87 | 
 88 |     addDragClass()
 89 | 
 90 |     return false
 91 |   }
 92 | 
 93 |   function onDragOver (event) {
 94 |     event.stopPropagation()
 95 |     event.preventDefault()
 96 | 
 97 |     if (!isEventHandleable(event)) return
 98 | 
 99 |     if (listeners.onDragOver) {
100 |       listeners.onDragOver(event)
101 |     }
102 | 
103 |     event.dataTransfer.dropEffect = 'copy'
104 | 
105 |     return false
106 |   }
107 | 
108 |   function onDragLeave (event) {
109 |     event.stopPropagation()
110 |     event.preventDefault()
111 | 
112 |     if (!isEventHandleable(event)) return
113 | 
114 |     if (numIgnoredEnters > 0) {
115 |       numIgnoredEnters -= 1
116 |       return false
117 |     }
118 | 
119 |     isEntered = false
120 | 
121 |     if (listeners.onDragLeave) {
122 |       listeners.onDragLeave(event)
123 |     }
124 | 
125 |     removeDragClass()
126 | 
127 |     return false
128 |   }
129 | 
130 |   function onDrop (event) {
131 |     event.stopPropagation()
132 |     event.preventDefault()
133 | 
134 |     if (listeners.onDragLeave) {
135 |       listeners.onDragLeave(event)
136 |     }
137 | 
138 |     removeDragClass()
139 | 
140 |     isEntered = false
141 |     numIgnoredEnters = 0
142 | 
143 |     const pos = {
144 |       x: event.clientX,
145 |       y: event.clientY
146 |     }
147 | 
148 |     // text drop support
149 |     const text = event.dataTransfer.getData('text')
150 |     if (text && listeners.onDropText) {
151 |       listeners.onDropText(text, pos)
152 |     }
153 | 
154 |     // File drop support. The `dataTransfer.items` API supports directories, so we
155 |     // use it instead of `dataTransfer.files`, even though it's much more
156 |     // complicated to use.
157 |     // See: https://github.com/feross/drag-drop/issues/39
158 |     if (listeners.onDrop && event.dataTransfer.items) {
159 |       processItems(event.dataTransfer.items, (err, files, directories) => {
160 |         if (err) {
161 |           // TODO: A future version of this library might expose this somehow
162 |           console.error(err)
163 |           return
164 |         }
165 | 
166 |         if (files.length === 0) return
167 | 
168 |         const fileList = event.dataTransfer.files
169 | 
170 |         // TODO: This callback has too many arguments, and the order is too
171 |         // arbitrary. In next major version, it should be cleaned up.
172 |         listeners.onDrop(files, pos, fileList, directories)
173 |       })
174 |     }
175 | 
176 |     return false
177 |   }
178 | 
179 |   function addDragClass () {
180 |     elem.classList.add('drag')
181 |   }
182 | 
183 |   function removeDragClass () {
184 |     elem.classList.remove('drag')
185 |   }
186 | }
187 | 
188 | function processItems (items, cb) {
189 |   // Handle directories in Chrome using the proprietary FileSystem API
190 |   items = Array.from(items).filter(item => {
191 |     return item.kind === 'file'
192 |   })
193 | 
194 |   if (items.length === 0) {
195 |     cb(null, [], [])
196 |   }
197 | 
198 |   parallel(items.map(item => {
199 |     return cb => {
200 |       processEntry(item.webkitGetAsEntry(), cb)
201 |     }
202 |   }), (err, results) => {
203 |     // This catches permission errors with file:// in Chrome
204 |     if (err) {
205 |       cb(err)
206 |       return
207 |     }
208 | 
209 |     const entries = results.flat(Infinity)
210 | 
211 |     const files = entries.filter(item => {
212 |       return item.isFile
213 |     })
214 | 
215 |     const directories = entries.filter(item => {
216 |       return item.isDirectory
217 |     })
218 | 
219 |     cb(null, files, directories)
220 |   })
221 | }
222 | 
223 | function processEntry (entry, cb) {
224 |   let entries = []
225 | 
226 |   if (entry.isFile) {
227 |     entry.file(file => {
228 |       file.fullPath = entry.fullPath // preserve path for consumer
229 |       file.isFile = true
230 |       file.isDirectory = false
231 |       cb(null, file)
232 |     }, err => {
233 |       cb(err)
234 |     })
235 |   } else if (entry.isDirectory) {
236 |     const reader = entry.createReader()
237 |     readEntries(reader)
238 |   }
239 | 
240 |   function readEntries (reader) {
241 |     reader.readEntries(currentEntries => {
242 |       if (currentEntries.length > 0) {
243 |         entries = entries.concat(Array.from(currentEntries))
244 |         readEntries(reader) // continue reading entries until `readEntries` returns no more
245 |       } else {
246 |         doneEntries()
247 |       }
248 |     })
249 |   }
250 | 
251 |   function doneEntries () {
252 |     parallel(entries.map(entry => {
253 |       return cb => {
254 |         processEntry(entry, cb)
255 |       }
256 |     }), (err, results) => {
257 |       if (err) {
258 |         cb(err)
259 |       } else {
260 |         results.push({
261 |           fullPath: entry.fullPath,
262 |           name: entry.name,
263 |           isFile: false,
264 |           isDirectory: true
265 |         })
266 |         cb(null, results)
267 |       }
268 |     })
269 |   }
270 | }
271 | 


--------------------------------------------------------------------------------