| 
				
			 | 
			
			
				@@ -94,21 +94,26 @@ export default class Blob extends EventTarget { 
			 | 
		
	
		
			
			| 
				94
			 | 
			
				94
			 | 
			
			
				       this.multipartBoundary = boundary 
			 | 
		
	
		
			
			| 
				95
			 | 
			
				95
			 | 
			
			
				       let parts = data.getParts() 
			 | 
		
	
		
			
			| 
				96
			 | 
			
				96
			 | 
			
			
				       let formArray = [] 
			 | 
		
	
		
			
			| 
				97
			 | 
			
				
			 | 
			
			
				-      for(let i in parts) { 
			 | 
		
	
		
			
			| 
				98
			 | 
			
				
			 | 
			
			
				-        formArray.push('\r\n--'+boundary+'\r\n') 
			 | 
		
	
		
			
			| 
				99
			 | 
			
				
			 | 
			
			
				-        let part = parts[i] 
			 | 
		
	
		
			
			| 
				100
			 | 
			
				
			 | 
			
			
				-        for(let j in part.headers) { 
			 | 
		
	
		
			
			| 
				101
			 | 
			
				
			 | 
			
			
				-          formArray.push(j + ': ' +part.headers[j] + ';\r\n') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				97
			 | 
			
			
				+      if(!parts) { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				98
			 | 
			
			
				+        p = fs.writeFile(this._ref, '', 'utf8') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				99
			 | 
			
			
				+      } 
			 | 
		
	
		
			
			| 
				
			 | 
			
				100
			 | 
			
			
				+      else { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				101
			 | 
			
			
				+        for(let i in parts) { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				102
			 | 
			
			
				+          formArray.push('\r\n--'+boundary+'\r\n') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				103
			 | 
			
			
				+          let part = parts[i] 
			 | 
		
	
		
			
			| 
				
			 | 
			
				104
			 | 
			
			
				+          for(let j in part.headers) { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				105
			 | 
			
			
				+            formArray.push(j + ': ' +part.headers[j] + ';\r\n') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				106
			 | 
			
			
				+          } 
			 | 
		
	
		
			
			| 
				
			 | 
			
				107
			 | 
			
			
				+          formArray.push('\r\n') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				108
			 | 
			
			
				+          if(part.isRNFetchBlobPolyfill) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				109
			 | 
			
			
				+            formArray.push(part) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				110
			 | 
			
			
				+          else 
			 | 
		
	
		
			
			| 
				
			 | 
			
				111
			 | 
			
			
				+            formArray.push(part.string) 
			 | 
		
	
		
			
			| 
				102
			 | 
			
				112
			 | 
			
			
				         } 
			 | 
		
	
		
			
			| 
				103
			 | 
			
				
			 | 
			
			
				-        formArray.push('\r\n') 
			 | 
		
	
		
			
			| 
				104
			 | 
			
				
			 | 
			
			
				-        if(part.isRNFetchBlobPolyfill) 
			 | 
		
	
		
			
			| 
				105
			 | 
			
				
			 | 
			
			
				-          formArray.push(part) 
			 | 
		
	
		
			
			| 
				106
			 | 
			
				
			 | 
			
			
				-        else 
			 | 
		
	
		
			
			| 
				107
			 | 
			
				
			 | 
			
			
				-          formArray.push(part.string) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				113
			 | 
			
			
				+        log.verbose('FormData array', formArray) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				114
			 | 
			
			
				+        formArray.push('\r\n--'+boundary+'--\r\n') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				115
			 | 
			
			
				+        p = createMixedBlobData(this._ref, formArray) 
			 | 
		
	
		
			
			| 
				108
			 | 
			
				116
			 | 
			
			
				       } 
			 | 
		
	
		
			
			| 
				109
			 | 
			
				
			 | 
			
			
				-      log.verbose('FormData array', formArray) 
			 | 
		
	
		
			
			| 
				110
			 | 
			
				
			 | 
			
			
				-      formArray.push('\r\n--'+boundary+'--\r\n') 
			 | 
		
	
		
			
			| 
				111
			 | 
			
				
			 | 
			
			
				-      p = createMixedBlobData(this._ref, formArray) 
			 | 
		
	
		
			
			| 
				112
			 | 
			
				117
			 | 
			
			
				     } 
			 | 
		
	
		
			
			| 
				113
			 | 
			
				118
			 | 
			
			
				     // if the data is a string starts with `RNFetchBlob-file://`, append the 
			 | 
		
	
		
			
			| 
				114
			 | 
			
				119
			 | 
			
			
				     // Blob data from file path 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -205,22 +210,25 @@ export default class Blob extends EventTarget { 
			 | 
		
	
		
			
			| 
				205
			 | 
			
				210
			 | 
			
			
				    * @param  {string} contentType Optional, content type of new Blob object 
			 | 
		
	
		
			
			| 
				206
			 | 
			
				211
			 | 
			
			
				    * @return {Blob} 
			 | 
		
	
		
			
			| 
				207
			 | 
			
				212
			 | 
			
			
				    */ 
			 | 
		
	
		
			
			| 
				208
			 | 
			
				
			 | 
			
			
				-  slice(start:?number, end:?number, contentType:?string):Blob { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				213
			 | 
			
			
				+  slice(start:?number, end:?number, contentType='':?string):Blob { 
			 | 
		
	
		
			
			| 
				209
			 | 
			
				214
			 | 
			
			
				     if(this._closed) 
			 | 
		
	
		
			
			| 
				210
			 | 
			
				215
			 | 
			
			
				       throw 'Blob has been released.' 
			 | 
		
	
		
			
			| 
				211
			 | 
			
				216
			 | 
			
			
				     log.verbose('slice called', start, end, contentType) 
			 | 
		
	
		
			
			| 
				212
			 | 
			
				217
			 | 
			
			
				     let resPath = blobCacheDir + getBlobName() 
			 | 
		
	
		
			
			| 
				213
			 | 
			
				218
			 | 
			
			
				     let pass = false 
			 | 
		
	
		
			
			| 
				214
			 | 
			
				219
			 | 
			
			
				     log.debug('fs.slice new blob will at', resPath) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				220
			 | 
			
			
				+    let result = new Blob(RNFetchBlob.wrap(resPath), { type : contentType }) 
			 | 
		
	
		
			
			| 
				215
			 | 
			
				221
			 | 
			
			
				     fs.slice(this._ref, resPath, start, end).then((dest) => { 
			 | 
		
	
		
			
			| 
				216
			 | 
			
				222
			 | 
			
			
				       log.debug('fs.slice done', dest) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				223
			 | 
			
			
				+      result._invokeOnCreateEvent() 
			 | 
		
	
		
			
			| 
				217
			 | 
			
				224
			 | 
			
			
				       pass = true 
			 | 
		
	
		
			
			| 
				218
			 | 
			
				225
			 | 
			
			
				     }) 
			 | 
		
	
		
			
			| 
				219
			 | 
			
				226
			 | 
			
			
				     .catch((err) => { 
			 | 
		
	
		
			
			| 
				220
			 | 
			
				227
			 | 
			
			
				       pass = true 
			 | 
		
	
		
			
			| 
				221
			 | 
			
				228
			 | 
			
			
				     }) 
			 | 
		
	
		
			
			| 
				222
			 | 
			
				229
			 | 
			
			
				     log.debug('slice returning new Blob') 
			 | 
		
	
		
			
			| 
				223
			 | 
			
				
			 | 
			
			
				-    return new Blob(RNFetchBlob.wrap(resPath)) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				230
			 | 
			
			
				+ 
			 | 
		
	
		
			
			| 
				
			 | 
			
				231
			 | 
			
			
				+    return result 
			 | 
		
	
		
			
			| 
				224
			 | 
			
				232
			 | 
			
			
				   } 
			 | 
		
	
		
			
			| 
				225
			 | 
			
				233
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				226
			 | 
			
				234
			 | 
			
			
				   /** 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -283,6 +291,8 @@ function createMixedBlobData(ref, dataArray) { 
			 | 
		
	
		
			
			| 
				283
			 | 
			
				291
			 | 
			
			
				   let size = 0 
			 | 
		
	
		
			
			| 
				284
			 | 
			
				292
			 | 
			
			
				   for(let i in dataArray) { 
			 | 
		
	
		
			
			| 
				285
			 | 
			
				293
			 | 
			
			
				     let part = dataArray[i] 
			 | 
		
	
		
			
			| 
				
			 | 
			
				294
			 | 
			
			
				+    if(!part) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				295
			 | 
			
			
				+      continue 
			 | 
		
	
		
			
			| 
				286
			 | 
			
				296
			 | 
			
			
				     if(part.isRNFetchBlobPolyfill) { 
			 | 
		
	
		
			
			| 
				287
			 | 
			
				297
			 | 
			
			
				       args.push([ref, part._ref, 'uri']) 
			 | 
		
	
		
			
			| 
				288
			 | 
			
				298
			 | 
			
			
				     } 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -296,27 +306,14 @@ function createMixedBlobData(ref, dataArray) { 
			 | 
		
	
		
			
			| 
				296
			 | 
			
				306
			 | 
			
			
				       args.push([ref, part, 'ascii']) 
			 | 
		
	
		
			
			| 
				297
			 | 
			
				307
			 | 
			
			
				   } 
			 | 
		
	
		
			
			| 
				298
			 | 
			
				308
			 | 
			
			
				   // start write blob data 
			 | 
		
	
		
			
			| 
				299
			 | 
			
				
			 | 
			
			
				-  // return p.then(() => { 
			 | 
		
	
		
			
			| 
				300
			 | 
			
				
			 | 
			
			
				-    for(let i in args) { 
			 | 
		
	
		
			
			| 
				301
			 | 
			
				
			 | 
			
			
				-      p = p.then(function(written){ 
			 | 
		
	
		
			
			| 
				302
			 | 
			
				
			 | 
			
			
				-        let arg = this 
			 | 
		
	
		
			
			| 
				303
			 | 
			
				
			 | 
			
			
				-        if(written) 
			 | 
		
	
		
			
			| 
				304
			 | 
			
				
			 | 
			
			
				-          size += written 
			 | 
		
	
		
			
			| 
				305
			 | 
			
				
			 | 
			
			
				-        log.verbose('mixed blob write', args[i], written) 
			 | 
		
	
		
			
			| 
				306
			 | 
			
				
			 | 
			
			
				-        return fs.appendFile(...arg) 
			 | 
		
	
		
			
			| 
				307
			 | 
			
				
			 | 
			
			
				-      }.bind(args[i])) 
			 | 
		
	
		
			
			| 
				308
			 | 
			
				
			 | 
			
			
				-    } 
			 | 
		
	
		
			
			| 
				309
			 | 
			
				
			 | 
			
			
				-    return p.then(() => Promise.resolve(size)) 
			 | 
		
	
		
			
			| 
				310
			 | 
			
				
			 | 
			
			
				-    // let promises = args.map((p) => { 
			 | 
		
	
		
			
			| 
				311
			 | 
			
				
			 | 
			
			
				-    //   log.verbose('mixed blob write', ...p) 
			 | 
		
	
		
			
			| 
				312
			 | 
			
				
			 | 
			
			
				-    //   return fs.appendFile.call(this, ...p) 
			 | 
		
	
		
			
			| 
				313
			 | 
			
				
			 | 
			
			
				-    // }) 
			 | 
		
	
		
			
			| 
				314
			 | 
			
				
			 | 
			
			
				-    // return Promise.all(promises).then((sizes) => { 
			 | 
		
	
		
			
			| 
				315
			 | 
			
				
			 | 
			
			
				-    //   log.verbose('blob write size', sizes) 
			 | 
		
	
		
			
			| 
				316
			 | 
			
				
			 | 
			
			
				-    //   for(let i in sizes) { 
			 | 
		
	
		
			
			| 
				317
			 | 
			
				
			 | 
			
			
				-    //     size += sizes[i] 
			 | 
		
	
		
			
			| 
				318
			 | 
			
				
			 | 
			
			
				-    //   } 
			 | 
		
	
		
			
			| 
				319
			 | 
			
				
			 | 
			
			
				-    //   return Promise.resolve(size) 
			 | 
		
	
		
			
			| 
				320
			 | 
			
				
			 | 
			
			
				-    // }) 
			 | 
		
	
		
			
			| 
				321
			 | 
			
				
			 | 
			
			
				-  // }) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				309
			 | 
			
			
				+  for(let i in args) { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				310
			 | 
			
			
				+    p = p.then(function(written){ 
			 | 
		
	
		
			
			| 
				
			 | 
			
				311
			 | 
			
			
				+      let arg = this 
			 | 
		
	
		
			
			| 
				
			 | 
			
				312
			 | 
			
			
				+      if(written) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				313
			 | 
			
			
				+        size += written 
			 | 
		
	
		
			
			| 
				
			 | 
			
				314
			 | 
			
			
				+      log.verbose('mixed blob write', args[i], written) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				315
			 | 
			
			
				+      return fs.appendFile(...arg) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				316
			 | 
			
			
				+    }.bind(args[i])) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				317
			 | 
			
			
				+  } 
			 | 
		
	
		
			
			| 
				
			 | 
			
				318
			 | 
			
			
				+  return p.then(() => Promise.resolve(size)) 
			 | 
		
	
		
			
			| 
				322
			 | 
			
				319
			 | 
			
			
				 } 
			 |