You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
			
				
					48 lines
				
				1.2 KiB
			
		
		
			
		
	
	
					48 lines
				
				1.2 KiB
			| 
								 
											4 years ago
										 
									 | 
							
								# minipass-flush
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								A Minipass stream that calls a flush function before emitting 'end'
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								## USAGE
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								```js
							 | 
						||
| 
								 | 
							
								const Flush = require('minipass-flush')
							 | 
						||
| 
								 | 
							
								cons f = new Flush({
							 | 
						||
| 
								 | 
							
								  flush (cb) {
							 | 
						||
| 
								 | 
							
								    // call the cb when done, or return a promise
							 | 
						||
| 
								 | 
							
								    // the 'end' event will wait for it, along with
							 | 
						||
| 
								 | 
							
								    // close, finish, and prefinish.
							 | 
						||
| 
								 | 
							
								    // call the cb with an error, or return a rejecting
							 | 
						||
| 
								 | 
							
								    // promise to emit 'error' instead of doing the 'end'
							 | 
						||
| 
								 | 
							
								    return rerouteAllEncryptions().then(() => clearAllChannels())
							 | 
						||
| 
								 | 
							
								  },
							 | 
						||
| 
								 | 
							
								  // all other minipass options accepted as well
							 | 
						||
| 
								 | 
							
								})
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								someDataSource.pipe(f).on('end', () => {
							 | 
						||
| 
								 | 
							
								  // proper flushing has been accomplished
							 | 
						||
| 
								 | 
							
								})
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								// Or as a subclass implementing a 'flush' method:
							 | 
						||
| 
								 | 
							
								class MyFlush extends Flush {
							 | 
						||
| 
								 | 
							
								  flush (cb) {
							 | 
						||
| 
								 | 
							
								    // old fashioned callback style!
							 | 
						||
| 
								 | 
							
								    rerouteAllEncryptions(er => {
							 | 
						||
| 
								 | 
							
								      if (er)
							 | 
						||
| 
								 | 
							
								        return cb(er)
							 | 
						||
| 
								 | 
							
								      clearAllChannels(er => {
							 | 
						||
| 
								 | 
							
								        if (er)
							 | 
						||
| 
								 | 
							
								          cb(er)
							 | 
						||
| 
								 | 
							
								        cb()
							 | 
						||
| 
								 | 
							
								      })
							 | 
						||
| 
								 | 
							
								    })
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								```
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								That's about it.
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								If your `flush` method doesn't have to do anything asynchronous, then it's
							 | 
						||
| 
								 | 
							
								better to call the callback right away in this tick, rather than returning
							 | 
						||
| 
								 | 
							
								`Promise.resolve()`, so that the `end` event can happen as soon as
							 | 
						||
| 
								 | 
							
								possible.
							 |