Added AbortController polyfill

.jshintrc

@@ -20,6 +20,10 @@
  "worker": true,
  "globals": {
  "JSON": false,
- "URLSearchParams": false
+ "URLSearchParams": false,
+ "AbortController": false,
+ "AbortSignal": false,
+ "DOMException": false,
+ "Event": false
  }
 }

fetch.js

@@ -464,3 +464,119 @@
  }
  self.fetch.polyfill = true
 })(typeof self !== 'undefined' ? self : this);
+(function(self) {
+ 'use strict';
+
+ if (self.AbortController) {
+ return
+ }
+
+ function Emitter() {
+ this.listeners = {}
+ }
+
+ Emitter.prototype.listeners = null
+ Emitter.prototype.addEventListener = function(type, callback) {
+ if (!(type in this.listeners)) {
+ this.listeners[type] = []
+ }
+ this.listeners[type].push(callback)
+ }
+
+ Emitter.prototype.removeEventListener = function(type, callback) {
+ if (!(type in this.listeners)) {
+ return
+ }
+ var stack = this.listeners[type]
+ for (var i = 0, l = stack.length; i < l; i++) {
+ if (stack[i] === callback){
+ stack.splice(i, 1)
+ return
+ }
+ }
+ }
+
+ Emitter.prototype.dispatchEvent = function(event) {
+ if (!(event.type in this.listeners)) {
+ return true
+ }
+ var stack = this.listeners[event.type]
+
+ for (var i = 0, l = stack.length; i < l; i++) {
+ stack[i].call(this, event)
+ }
+ return !event.defaultPrevented
+ }
+
+ function AbortSignal() {
+ Emitter.call(this)
+ this.aborted = false
+ }
+
+ AbortSignal.prototype = Object.create(Emitter.prototype)
+ AbortSignal.prototype.constructor = AbortSignal
+
+ AbortSignal.prototype.toString = function () {
+ return '[object AbortSignal]'
+ }
+
+
+ function AbortController() {
+ this.signal = new AbortSignal()
+ }
+
+ AbortController.prototype.abort = function() {
+ this.signal.aborted = true
+ this.signal.dispatchEvent(new Event('abort'))
+ }
+
+ AbortController.prototype.toString = function() {
+ return '[object AbortController]'
+ }
+
+ if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+ // These are necessary to make sure that we get correct output for:
+ // Object.prototype.toString.call(new AbortController())
+ AbortController.prototype[Symbol.toStringTag] = 'AbortController'
+ AbortSignal.prototype[Symbol.toStringTag] = 'AbortSignal'
+ }
+
+ var realFetch = fetch
+ var abortableFetch = function(input, init) {
+ if (init && init.signal) {
+ var abortError
+ try {
+ abortError = new DOMException('Aborted', 'AbortError')
+ } catch (err) {
+ // IE 11 does not support calling the DOMException constructor, use a
+ // regular error object on it instead.
+ abortError = new Error('Aborted')
+ abortError.name = 'AbortError'
+ }
+
+ // Return early if already aborted, thus avoiding making an HTTP request
+ if (init.signal.aborted) {
+ return Promise.reject(abortError)
+ }
+
+ // Turn an event into a promise, reject it once `abort` is dispatched
+ var cancellation = new Promise(function(_, reject) {
+ init.signal.addEventListener('abort', function() {
+ reject(abortError)
+ }, {once: true});
+ })
+
+ delete init.signal
+
+ // Return the fastest promise (don't need to wait for request to finish)
+ return Promise.race([cancellation, realFetch(input, init)])
+ }
+
+ return realFetch(input, init)
+ };
+
+ self.fetch = abortableFetch
+ self.AbortController = AbortController
+ self.AbortSignal = AbortSignal
+
+})(typeof self !== 'undefined' ? self : this);

script/server

@@ -95,6 +95,11 @@ var routes = {
  res.writeHead(200, {'Content-Type': 'application/json'});
  res.end('not json {');
  },
+ '/testAbort': function(res, req) {
+ setTimeout(function() {
+ res.end();
+ }, 200);
+ },
  '/cookie': function(res, req) {
  var setCookie, cookie
  var params = querystring.parse(url.parse(req.url).query);

test/test.js

@@ -1192,5 +1192,103 @@ suite('credentials mode', function() {
 })
 })
 
+suite('abort tests', function() {
+
+ test('abort during fetch', function() {
+ var controller = new AbortController()
+
+ setTimeout(function () {
+ controller.abort()
+ })
+
+ return fetch('/testAbort', {
+ signal: controller.signal
+ }).then(function () {
+ assert(false, 'Fetch should have been aborted')
+ }).catch(function (err) {
+ assert.equal(err.name, 'AbortError')
+ })
+ })
+
+ test('abort before fetch started', function() {
+ var controller = new AbortController()
+ controller.abort()
+
+ return fetch('/testAbort', {
+ signal: controller.signal
+ }).then(function () {
+ assert(false, 'Fetch should have been aborted')
+ }).catch(function (err) {
+ assert.equal(err.name, 'AbortError')
+ })
+ })
+
+ test('fetch without aborting', function() {
+ var controller = new AbortController()
+
+ return fetch('/testAbort', {
+ signal: controller.signal
+ }).catch(function () {
+ assert(false, 'Fetch should not have been aborted')
+ })
+ })
+
+ test('fetch without signal set', function() {
+ return fetch('/testAbort').catch(function () {
+ assert(false, 'Fetch should not have been aborted')
+ })
+ })
+
+ test('event listener fires "abort" event', function() {
+ return new Promise(function (resolve) {
+ var controller = new AbortController()
+ controller.signal.addEventListener('abort', function () {
+ resolve()
+ })
+ controller.abort()
+ })
+ })
+
+ test('signal.aborted is true after abort', function() {
+ return new Promise(function (resolve, reject) {
+ var controller = new AbortController()
+ controller.signal.addEventListener('abort', function () {
+ if (controller.signal.aborted === true) {
+ resolve()
+ } else {
+ reject()
+ }
+ })
+ controller.abort()
+ if (controller.signal.aborted !== true) {
+ reject()
+ }
+ })
+ })
+
+ test('event listener doesn\'t fire "abort" event after removeEventListener', function() {
+ return new Promise(function(resolve, reject) {
+ var controller = new AbortController()
+ controller.signal.addEventListener('abort', reject)
+ controller.signal.removeEventListener('abort', reject)
+ controller.abort()
+ resolve()
+ })
+ })
+
+
+ test('toString() output', function() {
+ assert.equal(new AbortController().toString(), '[object AbortController]')
+ assert.equal(new AbortController().signal.toString(), '[object AbortSignal]')
+ assert.equal(new AbortSignal().toString(), '[object AbortSignal]')
+
+ if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+ assert.equal(Object.prototype.toString.call(new AbortController()), '[object AbortController]')
+ assert.equal(Object.prototype.toString.call(new AbortSignal()), '[object AbortSignal]')
+ }
+
+ })
+})
+
  })
 })