[Summary view] [Print] [Text view]

   1  if (typeof FormData === 'undefined' || !FormData.prototype.keys) {
   2    const global = typeof window === 'object'
   3      ? window : typeof self === 'object'
   4      ? self : this
   5  
   6    // keep a reference to native implementation
   7    const _FormData = global.FormData
   8  
   9    // To be monkey patched
  10    const _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send
  11    const _fetch = global.Request && global.fetch
  12  
  13    // Unable to patch Request constructor correctly
  14    // const _Request = global.Request
  15    // only way is to use ES6 class extend
  16    // https://github.com/babel/babel/issues/1966
  17  
  18    const stringTag = global.Symbol && Symbol.toStringTag
  19    const map = new WeakMap
  20    const wm = o => map.get(o)
  21    const arrayFrom = Array.from || (obj => [].slice.call(obj))
  22  
  23    // Add missing stringTags to blob and files
  24    if (stringTag) {
  25      if (!Blob.prototype[stringTag]) {
  26        Blob.prototype[stringTag] = 'Blob'
  27      }
  28  
  29      if ('File' in global && !File.prototype[stringTag]) {
  30        File.prototype[stringTag] = 'File'
  31      }
  32    }
  33  
  34    // Fix so you can construct your own File
  35    try {
  36      new File([], '')
  37    } catch (a) {
  38      global.File = function(b, d, c) {
  39        const blob = new Blob(b, c)
  40        const t = c && void 0 !== c.lastModified ? new Date(c.lastModified) : new Date
  41  
  42        Object.defineProperties(blob, {
  43          name: {
  44            value: d
  45          },
  46          lastModifiedDate: {
  47            value: t
  48          },
  49          lastModified: {
  50            value: +t
  51          },
  52          toString: {
  53            value() {
  54              return '[object File]'
  55            }
  56          }
  57        })
  58  
  59        if (stringTag) {
  60          Object.defineProperty(blob, stringTag, {
  61            value: 'File'
  62          })
  63        }
  64  
  65        return blob
  66      }
  67    }
  68  
  69    function normalizeValue([value, filename]) {
  70      if (value instanceof Blob)
  71        // Should always returns a new File instance
  72        // console.assert(fd.get(x) !== fd.get(x))
  73        value = new File([value], filename, {
  74          type: value.type,
  75          lastModified: value.lastModified
  76        })
  77  
  78      return value
  79    }
  80  
  81    function stringify(name) {
  82      if (!arguments.length)
  83        throw new TypeError('1 argument required, but only 0 present.')
  84  
  85      return [name + '']
  86    }
  87  
  88    function normalizeArgs(name, value, filename) {
  89      if (arguments.length < 2)
  90        throw new TypeError(
  91          `2 arguments required, but only $arguments.length} present.`
  92        )
  93  
  94      return value instanceof Blob
  95        // normalize name and filename if adding an attachment
  96        ? [name + '', value, filename !== undefined
  97          ? filename + '' // Cast filename to string if 3th arg isn't undefined
  98          : typeof value.name === 'string' // if name prop exist
  99            ? value.name // Use File.name
 100            : 'blob'] // otherwise fallback to Blob
 101  
 102        // If no attachment, just cast the args to strings
 103        : [name + '', value + '']
 104    }
 105  
 106    function each (arr, cb) {
 107      for (let i = 0; i < arr.length; i++) {
 108        cb(arr[i])
 109      }
 110    }
 111  
 112    /**
 113     * @implements {Iterable}
 114     */
 115    class FormDataPolyfill {
 116  
 117      /**
 118       * FormData class
 119       *
 120       * @param {HTMLElement=} form
 121       */
 122      constructor(form) {
 123        map.set(this, Object.create(null))
 124  
 125        if (!form)
 126          return this
 127  
 128        const self = this
 129  
 130        each(form.elements, elm => {
 131          if (!elm.name || elm.disabled || elm.type === 'submit' || elm.type === 'button') return
 132  
 133          if (elm.type === 'file') {
 134            each(elm.files || [], file => {
 135              self.append(elm.name, file)
 136            })
 137          } else if (elm.type === 'select-multiple' || elm.type === 'select-one') {
 138            each(elm.options, opt => {
 139              !opt.disabled && opt.selected && self.append(elm.name, opt.value)
 140            })
 141          } else if (elm.type === 'checkbox' || elm.type === 'radio') {
 142            if (elm.checked) self.append(elm.name, elm.value)
 143          } else {
 144            self.append(elm.name, elm.value)
 145          }
 146        })
 147      }
 148  
 149  
 150      /**
 151       * Append a field
 152       *
 153       * @param   {String}           name      field name
 154       * @param   {String|Blob|File} value     string / blob / file
 155       * @param   {String=}          filename  filename to use with blob
 156       * @return  {Undefined}
 157       */
 158      append(name, value, filename) {
 159        const map = wm(this)
 160  
 161        if (!map[name])
 162          map[name] = []
 163  
 164        map[name].push([value, filename])
 165      }
 166  
 167  
 168      /**
 169       * Delete all fields values given name
 170       *
 171       * @param   {String}  name  Field name
 172       * @return  {Undefined}
 173       */
 174      delete(name) {
 175        delete wm(this)[name]
 176      }
 177  
 178  
 179      /**
 180       * Iterate over all fields as [name, value]
 181       *
 182       * @return {Iterator}
 183       */
 184      *entries() {
 185        const map = wm(this)
 186  
 187        for (let name in map)
 188          for (let value of map[name])
 189            yield [name, normalizeValue(value)]
 190      }
 191  
 192      /**
 193       * Iterate over all fields
 194       *
 195       * @param   {Function}  callback  Executed for each item with parameters (value, name, thisArg)
 196       * @param   {Object=}   thisArg   `this` context for callback function
 197       * @return  {Undefined}
 198       */
 199      forEach(callback, thisArg) {
 200        for (let [name, value] of this)
 201          callback.call(thisArg, value, name, this)
 202      }
 203  
 204  
 205      /**
 206       * Return first field value given name
 207       * or null if non existen
 208       *
 209       * @param   {String}  name      Field name
 210       * @return  {String|File|null}  value Fields value
 211       */
 212      get(name) {
 213        const map = wm(this)
 214        return map[name] ? normalizeValue(map[name][0]) : null
 215      }
 216  
 217  
 218      /**
 219       * Return all fields values given name
 220       *
 221       * @param   {String}  name  Fields name
 222       * @return  {Array}         [{String|File}]
 223       */
 224      getAll(name) {
 225        return (wm(this)[name] || []).map(normalizeValue)
 226      }
 227  
 228  
 229      /**
 230       * Check for field name existence
 231       *
 232       * @param   {String}   name  Field name
 233       * @return  {boolean}
 234       */
 235      has(name) {
 236        return name in wm(this)
 237      }
 238  
 239  
 240      /**
 241       * Iterate over all fields name
 242       *
 243       * @return {Iterator}
 244       */
 245      *keys() {
 246        for (let [name] of this)
 247          yield name
 248      }
 249  
 250  
 251      /**
 252       * Overwrite all values given name
 253       *
 254       * @param   {String}    name      Filed name
 255       * @param   {String}    value     Field value
 256       * @param   {String=}   filename  Filename (optional)
 257       * @return  {Undefined}
 258       */
 259      set(name, value, filename) {
 260        wm(this)[name] = [[value, filename]]
 261      }
 262  
 263  
 264      /**
 265       * Iterate over all fields
 266       *
 267       * @return {Iterator}
 268       */
 269      *values() {
 270        for (let [name, value] of this)
 271          yield value
 272      }
 273  
 274  
 275      /**
 276       * Return a native (perhaps degraded) FormData with only a `append` method
 277       * Can throw if it's not supported
 278       *
 279       * @return {FormData}
 280       */
 281      ['_asNative']() {
 282        const fd = new _FormData
 283  
 284        for (let [name, value] of this)
 285          fd.append(name, value)
 286  
 287        return fd
 288      }
 289  
 290  
 291      /**
 292       * [_blob description]
 293       *
 294       * @return {Blob} [description]
 295       */
 296      ['_blob']() {
 297        const boundary = '----formdata-polyfill-' + Math.random()
 298        const chunks = []
 299  
 300        for (let [name, value] of this) {
 301          chunks.push(`--$boundary}\r\n`)
 302  
 303          if (value instanceof Blob) {
 304            chunks.push(
 305              `Content-Disposition: form-data; name="$name}"; filename="$value.name}"\r\n`,
 306              `Content-Type: $value.type || 'application/octet-stream'}\r\n\r\n`,
 307              value,
 308              '\r\n'
 309            )
 310          } else {
 311            chunks.push(
 312              `Content-Disposition: form-data; name="$name}"\r\n\r\n$value}\r\n`
 313            )
 314          }
 315        }
 316  
 317        chunks.push(`--$boundary}--`)
 318  
 319        return new Blob(chunks, {type: 'multipart/form-data; boundary=' + boundary})
 320      }
 321  
 322  
 323      /**
 324       * The class itself is iterable
 325       * alias for formdata.entries()
 326       *
 327       * @return  {Iterator}
 328       */
 329      [Symbol.iterator]() {
 330        return this.entries()
 331      }
 332  
 333  
 334      /**
 335       * Create the default string description.
 336       *
 337       * @return  {String} [object FormData]
 338       */
 339      toString() {
 340        return '[object FormData]'
 341      }
 342    }
 343  
 344  
 345    if (stringTag) {
 346      /**
 347       * Create the default string description.
 348       * It is accessed internally by the Object.prototype.toString().
 349       *
 350       * @return {String} FormData
 351       */
 352      FormDataPolyfill.prototype[stringTag] = 'FormData'
 353    }
 354  
 355    const decorations = [
 356      ['append', normalizeArgs],
 357      ['delete', stringify],
 358      ['get',    stringify],
 359      ['getAll', stringify],
 360      ['has',    stringify],
 361      ['set',    normalizeArgs]
 362    ]
 363  
 364    decorations.forEach(arr => {
 365      const orig = FormDataPolyfill.prototype[arr[0]]
 366      FormDataPolyfill.prototype[arr[0]] = function() {
 367        return orig.apply(this, arr[1].apply(this, arrayFrom(arguments)))
 368      }
 369    })
 370  
 371    // Patch xhr's send method to call _blob transparently
 372    if (_send) {
 373      XMLHttpRequest.prototype.send = function(data) {
 374        // I would check if Content-Type isn't already set
 375        // But xhr lacks getRequestHeaders functionallity
 376        // https://github.com/jimmywarting/FormData/issues/44
 377        if (data instanceof FormDataPolyfill) {
 378          const blob = data['_blob']()
 379          this.setRequestHeader('Content-Type', blob.type)
 380          _send.call(this, blob)
 381        } else {
 382          _send.call(this, data)
 383        }
 384      }
 385    }
 386  
 387    // Patch fetch's function to call _blob transparently
 388    if (_fetch) {
 389      const _fetch = global.fetch
 390  
 391      global.fetch = function(input, init) {
 392        if (init && init.body && init.body instanceof FormDataPolyfill) {
 393          init.body = init.body['_blob']()
 394        }
 395  
 396        return _fetch(input, init)
 397      }
 398    }
 399  
 400    global['FormData'] = FormDataPolyfill
 401  }