@ama-sdk/client-fetch 12.3.0-prerelease.70 → 12.3.0-prerelease.72

package/esm2015/plugins/abort/abort.spec.js

@@ -120,77 +120,83 @@ function _ts_generator(thisArg, body) {
 }
 import { AbortFetch } from './abort.fetch';
 describe('Abort Plugin', function() {
-    it('should trigger the callback', /*#__PURE__*/ _async_to_generator(function() {
-        var fn, plugin, runner;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    fn = jest.fn();
-                    plugin = new AbortFetch(fn);
-                    runner = plugin.load({});
-                    return [
-                        4,
-                        runner.transform(Promise.resolve())
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(fn).toHaveBeenCalled();
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should trigger abort signal if true', /*#__PURE__*/ _async_to_generator(function() {
-        var defaultContext, fn, plugin, runner;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    defaultContext = {
-                        controller: {
-                            abort: jest.fn()
-                        }
-                    };
-                    fn = jest.fn().mockResolvedValue(true);
-                    plugin = new AbortFetch(fn);
-                    runner = plugin.load(defaultContext);
-                    return [
-                        4,
-                        runner.transform(Promise.resolve())
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(defaultContext.controller.abort).toHaveBeenCalled();
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should not trigger abort signal if false', /*#__PURE__*/ _async_to_generator(function() {
-        var defaultContext, fn, plugin, runner;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    defaultContext = {
-                        controller: {
-                            abort: jest.fn()
-                        }
-                    };
-                    fn = jest.fn().mockResolvedValue(false);
-                    plugin = new AbortFetch(fn);
-                    runner = plugin.load(defaultContext);
-                    return [
-                        4,
-                        runner.transform(Promise.resolve())
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(defaultContext.controller.abort).not.toHaveBeenCalled();
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('should trigger the callback', function() {
+        return _async_to_generator(function() {
+            var fn, plugin, runner;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        fn = jest.fn();
+                        plugin = new AbortFetch(fn);
+                        runner = plugin.load({});
+                        return [
+                            4,
+                            runner.transform(Promise.resolve())
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(fn).toHaveBeenCalled();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should trigger abort signal if true', function() {
+        return _async_to_generator(function() {
+            var defaultContext, fn, plugin, runner;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        defaultContext = {
+                            controller: {
+                                abort: jest.fn()
+                            }
+                        };
+                        fn = jest.fn().mockResolvedValue(true);
+                        plugin = new AbortFetch(fn);
+                        runner = plugin.load(defaultContext);
+                        return [
+                            4,
+                            runner.transform(Promise.resolve())
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(defaultContext.controller.abort).toHaveBeenCalled();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should not trigger abort signal if false', function() {
+        return _async_to_generator(function() {
+            var defaultContext, fn, plugin, runner;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        defaultContext = {
+                            controller: {
+                                abort: jest.fn()
+                            }
+                        };
+                        fn = jest.fn().mockResolvedValue(false);
+                        plugin = new AbortFetch(fn);
+                        runner = plugin.load(defaultContext);
+                        return [
+                            4,
+                            runner.transform(Promise.resolve())
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(defaultContext.controller.abort).not.toHaveBeenCalled();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });

package/esm2015/plugins/concurrent/concurrent.fetch.js

@@ -187,20 +187,19 @@ function _ts_generator(thisArg, body) {
             value: /** @inheritDoc */ function load(_context) {
                 var _this = this;
                 this.poolSize++;
-                var _this1 = this;
                 return {
                     canStart: function() {
                         return new Promise(function(resolve) {
                             return _this.canStart() ? resolve(true) : _this.waitingResolvers.push(resolve);
                         });
                     },
-                    transform: /*#__PURE__*/ function() {
-                        var _ref = _async_to_generator(function(fetchCall) {
+                    transform: function(fetchCall) {
+                        return _async_to_generator(function() {
                             var fetchResponse;
                             return _ts_generator(this, function(_state) {
                                 switch(_state.label){
                                     case 0:
-                                        _this1.pool.push(fetchCall);
+                                        this.pool.push(fetchCall);
                                         _state.label = 1;
                                     case 1:
                                         _state.trys.push([
@@ -220,11 +219,11 @@ function _ts_generator(thisArg, body) {
                                             fetchResponse
                                         ];
                                     case 3:
-                                        _this1.pool = _this1.pool.filter(function(call) {
+                                        this.pool = this.pool.filter(function(call) {
                                             return call !== fetchCall;
                                         });
-                                        _this1.poolSize--;
-                                        _this1.unstackResolve();
+                                        this.poolSize--;
+                                        this.unstackResolve();
                                         return [
                                             7
                                         ];
@@ -234,11 +233,8 @@ function _ts_generator(thisArg, body) {
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }

package/esm2015/plugins/concurrent/concurrent.spec.js

@@ -120,27 +120,29 @@ function _ts_generator(thisArg, body) {
 }
 import { ConcurrentFetch } from './concurrent.fetch';
 describe('Concurrent Fetch Plugin', function() {
-    it('should start if the limit is not reach', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, canStart;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new ConcurrentFetch(3);
-                    plugin.load({});
-                    runner = plugin.load({});
-                    return [
-                        4,
-                        runner.canStart()
-                    ];
-                case 1:
-                    canStart = _state.sent();
-                    expect(canStart).toBe(true);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('should start if the limit is not reach', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, canStart;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new ConcurrentFetch(3);
+                        plugin.load({});
+                        runner = plugin.load({});
+                        return [
+                            4,
+                            runner.canStart()
+                        ];
+                    case 1:
+                        canStart = _state.sent();
+                        expect(canStart).toBe(true);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
     it('should retrieve the fetch call in the pool', function() {
         var plugin = new ConcurrentFetch(3);
         var call = new Promise(function(resolve) {
@@ -158,74 +160,76 @@ describe('Concurrent Fetch Plugin', function() {
         void plugin.load({}).transform(test);
         expect(plugin.pool[2]).toBe(test);
     });
-    it('should start only when the pool is available', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, resolves, call0, call1, result, runner1, canStart1, runner2, pCanStart2;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new ConcurrentFetch(2);
-                    resolves = [
-                        null,
-                        null
-                    ];
-                    call0 = new Promise(function(resolve) {
-                        return resolves[0] = resolve;
-                    });
-                    call1 = new Promise(function(resolve) {
-                        return resolves[1] = resolve;
-                    });
-                    result = {
-                        res: false
-                    };
-                    void plugin.load({}).transform(call0);
-                    runner1 = plugin.load({});
-                    canStart1 = runner1.canStart();
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        4,
-                        canStart1
-                    ];
-                case 2:
-                    expect.apply(void 0, [
-                        _state.sent()
-                    ]).toBe(true);
-                    void runner1.transform(call1);
-                    runner2 = plugin.load({});
-                    pCanStart2 = runner2.canStart();
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 3:
-                    _state.sent();
-                    expect(plugin.waitingResolvers.length).toBe(1);
-                    result.res = true;
-                    resolves[0]();
-                    return [
-                        4,
-                        pCanStart2
-                    ];
-                case 4:
-                    expect.apply(void 0, [
-                        _state.sent()
-                    ]).toBe(true);
-                    resolves[1]();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(500)
-                    ];
-                case 5:
-                    _state.sent();
-                    expect(plugin.waitingResolvers.length).toBe(0);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('should start only when the pool is available', function() {
+        return _async_to_generator(function() {
+            var plugin, resolves, call0, call1, result, runner1, canStart1, runner2, pCanStart2;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new ConcurrentFetch(2);
+                        resolves = [
+                            null,
+                            null
+                        ];
+                        call0 = new Promise(function(resolve) {
+                            return resolves[0] = resolve;
+                        });
+                        call1 = new Promise(function(resolve) {
+                            return resolves[1] = resolve;
+                        });
+                        result = {
+                            res: false
+                        };
+                        void plugin.load({}).transform(call0);
+                        runner1 = plugin.load({});
+                        canStart1 = runner1.canStart();
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            canStart1
+                        ];
+                    case 2:
+                        expect.apply(void 0, [
+                            _state.sent()
+                        ]).toBe(true);
+                        void runner1.transform(call1);
+                        runner2 = plugin.load({});
+                        pCanStart2 = runner2.canStart();
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 3:
+                        _state.sent();
+                        expect(plugin.waitingResolvers.length).toBe(1);
+                        result.res = true;
+                        resolves[0]();
+                        return [
+                            4,
+                            pCanStart2
+                        ];
+                    case 4:
+                        expect.apply(void 0, [
+                            _state.sent()
+                        ]).toBe(true);
+                        resolves[1]();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(500)
+                        ];
+                    case 5:
+                        _state.sent();
+                        expect(plugin.waitingResolvers.length).toBe(0);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });

package/esm2015/plugins/keepalive/keepalive.request.js

@@ -213,7 +213,6 @@ function _ts_generator(thisArg, body) {
    * https://bugs.chromium.org/p/chromium/issues/detail?id=835821
    * To avoid this issue we do a fake fetch call to check whether we can activate it or not in the browser.
    */ function testKeepAlive() {
-                var _this = this;
                 return _async_to_generator(function() {
                     var customHeaders, e;
                     return _ts_generator(this, function(_state) {
@@ -238,14 +237,14 @@ function _ts_generator(thisArg, body) {
                                 ];
                             case 2:
                                 _state.sent();
-                                _this.active = true;
+                                this.active = true;
                                 return [
                                     3,
                                     4
                                 ];
                             case 3:
                                 e = _state.sent();
-                                _this.active = false;
+                                this.active = false;
                                 return [
                                     3,
                                     4
@@ -256,7 +255,7 @@ function _ts_generator(thisArg, body) {
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {

package/esm2015/plugins/keepalive/keepalive.spec.js

@@ -125,30 +125,32 @@ describe('Keepalive Request Plugin', function() {
         basePath: 'http://test.com/truc',
         method: 'get'
     };
-    it('keepalive should be set to true', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, keepalive;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new KeepaliveRequest(true);
-                    runner = plugin.load();
-                    return [
-                        4,
-                        runner.transform(options)
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        4,
-                        plugin.load().transform(options)
-                    ];
-                case 2:
-                    keepalive = _state.sent().keepalive;
-                    expect(keepalive).toBe(true);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('keepalive should be set to true', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, keepalive;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new KeepaliveRequest(true);
+                        runner = plugin.load();
+                        return [
+                            4,
+                            runner.transform(options)
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            plugin.load().transform(options)
+                        ];
+                    case 2:
+                        keepalive = _state.sent().keepalive;
+                        expect(keepalive).toBe(true);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });

package/esm2015/plugins/mock-intercept/mock-intercept.fetch.js

@@ -174,22 +174,22 @@ import { CUSTOM_MOCK_OPERATION_ID_HEADER, MockInterceptRequest } from '@ama-sdk/
         {
             key: "load",
             value: function load(context) {
+                var _this = this;
                 if (!context.apiClient.options.requestPlugins.some(function(plugin) {
                     return _instanceof(plugin, MockInterceptRequest);
                 })) {
                     throw new Error('MockInterceptFetch plugin should be used only with the MockInterceptRequest plugin');
                 }
-                var _this = this;
                 return {
-                    transform: /*#__PURE__*/ function() {
-                        var _ref = _async_to_generator(function(fetchCall) {
+                    transform: function(fetchCall) {
+                        return _async_to_generator(function() {
                             var responsePromise, delay, _tmp, resp, operationId, mock, response;
                             return _ts_generator(this, function(_state) {
                                 switch(_state.label){
                                     case 0:
                                         return [
                                             4,
-                                            _this.options.adapter.initialize()
+                                            this.options.adapter.initialize()
                                         ];
                                     case 1:
                                         _state.sent();
@@ -200,15 +200,15 @@ import { CUSTOM_MOCK_OPERATION_ID_HEADER, MockInterceptRequest } from '@ama-sdk/
                                                 responsePromise
                                             ];
                                         }
-                                        if (!(typeof _this.options.delayTiming !== 'undefined')) return [
+                                        if (!(typeof this.options.delayTiming !== 'undefined')) return [
                                             3,
                                             6
                                         ];
-                                        if (!(typeof _this.options.delayTiming === 'number')) return [
+                                        if (!(typeof this.options.delayTiming === 'number')) return [
                                             3,
                                             2
                                         ];
-                                        _tmp = _this.options.delayTiming;
+                                        _tmp = this.options.delayTiming;
                                         return [
                                             3,
                                             4
@@ -216,7 +216,7 @@ import { CUSTOM_MOCK_OPERATION_ID_HEADER, MockInterceptRequest } from '@ama-sdk/
                                     case 2:
                                         return [
                                             4,
-                                            _this.options.delayTiming(context)
+                                            this.options.delayTiming(context)
                                         ];
                                     case 3:
                                         _tmp = _state.sent();
@@ -238,7 +238,7 @@ import { CUSTOM_MOCK_OPERATION_ID_HEADER, MockInterceptRequest } from '@ama-sdk/
                                     case 6:
                                         operationId = context.options.headers.get(CUSTOM_MOCK_OPERATION_ID_HEADER);
                                         try {
-                                            mock = _this.options.adapter.getLatestMock(operationId);
+                                            mock = this.options.adapter.getLatestMock(operationId);
                                             if (!mock.getResponse) {
                                                 return [
                                                     2,
@@ -264,11 +264,8 @@ import { CUSTOM_MOCK_OPERATION_ID_HEADER, MockInterceptRequest } from '@ama-sdk/
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }