Add Blob size support #44

src/index.js

@@ -13,7 +13,8 @@ import {
 import type {
   RNFetchBlobNative,
   RNFetchBlobConfig,
-  RNFetchBlobStream
+  RNFetchBlobStream,
+  RNFetchBlobResponseInfo
 } from './types'
 import fs from './fs'
 import getUUID from './utils/uuid'
@@ -142,7 +143,7 @@ function fetch(...args:any):Promise {
     }
 
     let req = RNFetchBlob[nativeMethodName]
-    req(options, taskId, method, url, headers || {}, body, (err, data) => {
+    req(options, taskId, method, url, headers || {}, body, (err, info, data) => {
 
       // task done, remove event listener
       subscription.remove()
@@ -151,14 +152,16 @@ function fetch(...args:any):Promise {
       if(err)
         reject(new Error(err, data))
       else {
-        let respType = 'base64'
+        let rnfbEncode = 'base64'
         // response data is saved to storage
         if(options.path || options.fileCache || options.addAndroidDownloads || options.key) {
-          respType = 'path'
+          rnfbEncode = 'path'
           if(options.session)
             session(options.session).add(data)
         }
-        resolve(new FetchBlobResponse(taskId, respType, data))
+        info = Object.assign({}, info, { rnfbEncode })
+
+        resolve(new FetchBlobResponse(taskId, info, data))
       }
     })
 
@@ -204,16 +207,22 @@ class FetchBlobResponse {
   json : () => any;
   base64 : () => any;
   flush : () => void;
+  respInfo : RNFetchBlobResponseInfo;
   session : (name:string) => RNFetchBlobSession | null;
   readFile : (encode: 'base64' | 'utf8' | 'ascii') => ?Promise;
   readStream : (
     encode: 'utf8' | 'ascii' | 'base64',
   ) => RNFetchBlobStream | null;
 
-  constructor(taskId:string, type:'base64' | 'path', data:any) {
+  constructor(taskId:string, info:RNFetchBlobResponseInfo, data:any) {
     this.data = data
     this.taskId = taskId
-    this.type = type
+    this.type = info.rnfbEncode
+    this.respInfo = info
+
+    this.info = ():RNFetchBlobResponseInfo => {
+      return this.respInfo
+    }
     /**
      * Convert result to javascript Blob object.
      * @param  {string} contentType MIME type of the blob object.

src/polyfill/Blob.js

@@ -27,10 +27,24 @@ export default class Blob {
   _blobCreated:boolean = false;
   _onCreated:Array<any> = [];
 
-  static Instances:any = {}
+  /**
+   * Static method that remove all files in Blob cache folder.
+   * @nonstandard
+   * @return {Promise}
+   */
+  static clearCache() {
+    return fs.unlink(blobCacheDir).then(() => fs.mkdir(blobCacheDir))
+  }
 
-  // legacy constructor
-  constructor(data:any, mime:?string) {
+  /**
+   * RNFetchBlob Blob polyfill, create a Blob directly from file path, BASE64
+   * encoded data, and string. The conversion is done implicitly according to
+   * given `mime`. However, the blob creation is asynchronously, to register
+   * event `onCreated` is need to ensure the Blob is creadted.
+   * @param  {any} data Content of Blob object
+   * @param  {string} mime Content type of Blob object, `text/plain` by default
+   */
+  constructor(data:any, mime='text/plain':?string) {
 
     this.cacheName = getBlobName()
     this.isRNFetchBlobPolyfill = true
@@ -38,22 +52,28 @@ export default class Blob {
     log.verbose('Blob constructor called', 'mime', mime)
     this._ref = blobCacheDir + this.cacheName
     let p = null
-    // content from file
+    // if the data is a string starts with `RNFetchBlob-file://`, append the
+    // Blob data from file path
     if(typeof data === 'string' && data.startsWith('RNFetchBlob-file://')) {
       log.verbose('create Blob cache file from file path')
       this._ref = data
-      p = Promise.resolve()
+      p = fs.stat(data.replace('RNFetchBlob-file://'))
+            .then((stat) =>  Promise.resolve(stat.size))
     }
     // content from variable need create file
     else if(typeof data === 'string') {
       log.verbose('create Blob cache file from string')
       let encoding = 'utf8'
-      if(String(mime).match('application/octet'))
+      let mime = String(mime)
+      // when content type contains application/octet* or *;base64, RNFetchBlob
+      // fs will treat it as BASE64 encoded string binary data
+      if(mime.match(/application\/octet/i) || mime.match(/\;base64/i))
         encoding = 'base64'
-      else if(Array.isArray(data))
-        encoding = 'ascii'
+      else
+        data = data.toString()
       // create cache file
       p = fs.writeFile(this._ref, data, encoding)
+            .then((size) => Promise.resolve(size))
 
     }
     // when input is an array of mixed data types, create a file cache
@@ -61,21 +81,34 @@ export default class Blob {
       log.verbose('create Blob cache file from mixed array', data)
       p = createMixedBlobData(this._ref, data)
     }
-    p && p.then(() => {
+    else {
+      data = data.toString()
+      p = Promise.resolve(data.length)
+    }
+    p && p.then((size) => {
+      this.size = size
       this._invokeOnCreateEvent()
     })
     .catch((err) => {
-      log.error('RNFetchBlob cannot create Blob : '+ this._ref)
+      log.error('RNFetchBlob could not create Blob : '+ this._ref, err)
     })
 
   }
 
+  /**
+   * Since Blob content will asynchronously write to a file during creation,
+   * use this method to register an event handler for Blob initialized event.
+   * @nonstandard
+   * @param  {[type]} fn:( [description]
+   * @return {[type]}      [description]
+   */
   onCreated(fn:() => void) {
     log.verbose('register blob onCreated', this._onCreated.length)
     this._onCreated.push(fn)
   }
 
   /**
+   * Get file reference of the Blob object.
    * @nonstandard
    * @return {string} Blob file reference which can be consumed by RNFetchBlob fs
    */
@@ -92,6 +125,7 @@ export default class Blob {
    */
   slice(start:?number, end:?number, encoding:?string):Blob {
     log.verbose('slice called')
+    // TODO : fs.slice
     // return fs.slice(this.cacheName, getBlobName(), contentType, start, end)
   }
 
@@ -104,10 +138,6 @@ export default class Blob {
     return fs.unlink(this._ref)
   }
 
-  clearCache() {
-
-  }
-
   _invokeOnCreateEvent() {
     log.verbose('invoke create event')
     this._blobCreated = true
@@ -139,6 +169,7 @@ function getBlobName() {
 function createMixedBlobData(ref, dataArray) {
   let p = fs.writeFile(ref, '')
   let args = []
+  let size = 0
   for(let i in dataArray) {
     let part = dataArray[i]
     if(part instanceof Blob)
@@ -152,6 +183,11 @@ function createMixedBlobData(ref, dataArray) {
     let promises = args.map((p) => {
       return fs.appendFile.call(this, ...p)
     })
-    return Promise.all(promises)
+    return Promise.all(promises).then((sizes) => {
+      for(let i in sizes) {
+        size += sizes[i]
+      }
+      return Promise.resolve(size)
+    })
   })
 }

src/polyfill/XMLHttpRequest.js

@@ -222,12 +222,11 @@ export default class XMLHttpRequest extends XMLHttpRequestEventTarget{
             this._response = resp.json()
         }
         else {
-          this._responseType = resp.text()
+          this._responseText = resp.text()
           this._response = this.responseText
         }
       break;
       case 'path' :
-        this.responseType = 'blob'
         this.response = resp.blob()
       break;
     }