code refactor #70

src/index.js

      * @return {object} Parsed javascript object.
      */
     this.json = ():any => {
-      return JSON.parse(base64.decode(this.data))
+      return JSON.parse(decodeURIComponent(base64.decode(this.data)))
     }
     /**
      * Return BASE64 string directly.

src/polyfill/Fetch.js

 
 log.level(3)
 
-
 export default class Fetch {
 
-  provider:RNFetchBlobFetch;
-
   constructor(config:RNFetchBlobConfig) {
-    this.provider = new RNFetchBlobFetch(config)
+    Object.assign(this, new RNFetchBlobFetchPolyfill(config))
   }
 
 }
 
-class RNFetchBlobFetch {
+class RNFetchBlobFetchPolyfill {
 
   constructor(config:RNFetchBlobConfig) {
-    this._fetch = (url, options) => {
-      let bodyUsed = false
+    this.build = () => (url, options) => {
       options.headers = options.headers || {}
       options['Content-Type'] = options.headers['Content-Type'] || options.headers['content-type']
       options['content-type'] = options.headers['Content-Type'] || options.headers['content-type']
         .fetch(options.method, url, options.headers, options.body)
         .then((resp) => {
           let info = resp.info()
-          return Promise.resolve({
-            headers : info.headers,
-            ok : info.status >= 200 && info.status <= 299,
-            status : info.status,
-            type : 'basic',
-            bodyUsed,
-            arrayBuffer : () => {
-              log.verbose('to arrayBuffer', info)
-
-            },
-            text : () => {
-              log.verbose('to text', resp, info)
-              switch (info.rnfbEncode) {
-                case 'base64':
-                  let result = unicode(resp.text())
-                  return Promise.resolve(result)
-                  break
-                case 'path':
-                  return resp.readFile('utf8').then((data) => {
-                    data = unicode(data)
-                    return Promise.resolve(data)
-                  })
-                  break
-                case '':
-                default:
-                  return Promise.resolve(resp.data)
-                  break
-              }
-            },
-            json : () => {
-              log.verbose('to json', resp, info)
-              switch (info.rnfbEncode) {
-                case 'base64':
-                  return Promise.resolve(resp.json())
-                case 'path':
-                  return resp.readFile('utf8').then((data) => {
-                    return Promise.resolve(JSON.parse(data))
-                  })
-                case '':
-                default:
-                  return Promise.resolve(JSON.parse(resp.data))
-              }
-            },
-            formData : () => {
-              log.verbose('to formData', resp, info)
-
-            }
-          })
+          return Promise.resolve(new RNFetchBlobFetchRepsonse(resp))
         })
     }
   }
 
-  get fetch() {
-    return this._fetch
+}
+
+class RNFetchBlobFetchRepsonse {
+
+  constructor(resp:FetchBlobResponse) {
+    let info = resp.info()
+    this.headers = info.headers
+    this.ok = info.status >= 200 && info.status <= 299,
+    this.status = info.status
+    this.type = 'basic'
+    this.bodyUsed = false
+    this.resp = resp
+    this.rnfbRespInfo = info
+    this.rnfbResp = resp
+  }
+
+  arrayBuffer(){
+    log.verbose('to arrayBuffer', this.rnfbRespInfo)
+    return readArrayBuffer(this.rnfbResp, this.rnfbRespInfo)
+  }
+
+  text() {
+    log.verbose('to text', this.rnfbResp, this.rnfbRespInfo)
+    return readText(this.rnfbResp, this.rnfbRespInfo)
+  }
+
+  json() {
+    log.verbose('to json', this.rnfbResp, this.rnfbRespInfo)
+    return readJSON(this.rnfbResp, this.rnfbRespInfo)
   }
 
+  formData() {
+    log.verbose('to formData', this.rnfbResp, this.rnfbRespInfo)
+    return readFormData(this.rnfbResp, this.rnfbRespInfo)
+  }
+
+  blob() {
+    log.verbose('to blob', this.rnfbResp, this.rnfbRespInfo)
+    return readBlob(this.rnfbResp, this.rnfbRespInfo)
+  }
+}
+
+
+function readText(resp, info):Promise<string> {
+  switch (info.rnfbEncode) {
+    case 'base64':
+      return Promise.resolve(resp.text())
+      break
+    case 'path':
+      return resp.readFile('utf8').then((data) => {
+        data = unicode(data)
+        return Promise.resolve(data)
+      })
+      break
+    default:
+      return Promise.resolve(resp.text())
+      break
+  }
+}
+
+function readJSON(resp, info):Promise<object> {
+  switch (info.rnfbEncode) {
+    case 'base64':
+      return Promise.resolve(resp.json())
+    case 'path':
+      return resp.readFile('utf8').then((data) => {
+        return Promise.resolve(JSON.parse(data))
+      })
+    default:
+      return Promise.resolve(JSON.parse(resp.data))
+  }
 }

test/test-0.8.2.js

 window.fetch = new RNFetchBlob.polyfill.Fetch({
   auto : true,
   binaryContentTypes : ['image/', 'video/', 'audio/']
-}).provider.fetch
+}).build()
 
 const fs = RNFetchBlob.fs
 const { Assert, Comparer, Info, prop } = RNTest
 
 let prefix = ((Platform.OS === 'android') ? 'file://' : '')
 
-describe('unicode file access', (report, done) => {
-  let path = dirs.DocumentDir + '/chinese.tmp'
-  fs.writeFile(path, '你好!', 'utf8')
-    .then(() => fs.readFile(path, 'utf8'))
-    .then((data) => {
-      console.log(data)
-      done()
-    })
-})
-
 describe('whatwg-fetch - GET should work correctly', (report, done) => {
   console.log(fetch)
   fetch(`${TEST_SERVER_URL}/unicode`, {
     method : 'GET'
   })
   .then((res) => {
-    console.log('fetch resp',res)
-    return res.text()
+    return res.json()
   })
-  .then((blob) => {
-    console.log(blob)
+  .then((data) => {
+    console.log(data)
+    report(<Assert key="data should correct" expect={'你好!'} actual={data.data}/>)
     done()
   })
 })