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

package/esm2015/plugins/retry/retry.fetch.js

@@ -210,7 +210,6 @@ import { CanceledCallError } from '@ama-sdk/core';
         {
             key: "delay",
             value: function delay(countDown) {
-                var _this = this;
                 return _async_to_generator(function() {
                     var time;
                     return _ts_generator(this, function(_state) {
@@ -218,7 +217,7 @@ import { CanceledCallError } from '@ama-sdk/core';
                             case 0:
                                 return [
                                     4,
-                                    _this.sleepBetweenRetry(countDown)
+                                    this.sleepBetweenRetry(countDown)
                                 ];
                             case 1:
                                 time = _state.sent();
@@ -230,40 +229,39 @@ import { CanceledCallError } from '@ama-sdk/core';
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {
             key: "waitAndRetry",
             value: function waitAndRetry(context, countDown) {
-                var _this = this;
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 return [
                                     4,
-                                    _this.delay(countDown)
+                                    this.delay(countDown)
                                 ];
                             case 1:
                                 _state.sent();
                                 return [
                                     2,
-                                    _this.retry(context)
+                                    this.retry(context)
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {
             key: "load",
             value: /** @inheritDoc */ function load(context) {
-                var countDown = this.numberOfRetry;
                 var _this = this;
+                var countDown = this.numberOfRetry;
                 return {
-                    transform: /*#__PURE__*/ function() {
-                        var _ref = _async_to_generator(function(fetchCall) {
+                    transform: function(fetchCall) {
+                        return _async_to_generator(function() {
                             var result, conditionResult, e, conditionResult1;
                             return _ts_generator(this, function(_state) {
                                 switch(_state.label){
@@ -286,7 +284,7 @@ import { CanceledCallError } from '@ama-sdk/core';
                                         ];
                                         return [
                                             4,
-                                            _this.condition(context, result.clone())
+                                            this.condition(context, result.clone())
                                         ];
                                     case 2:
                                         conditionResult = _state.sent();
@@ -294,7 +292,7 @@ import { CanceledCallError } from '@ama-sdk/core';
                                             countDown--;
                                             return [
                                                 2,
-                                                _this.waitAndRetry(context, countDown)
+                                                this.waitAndRetry(context, countDown)
                                             ];
                                         }
                                         _state.label = 3;
@@ -311,7 +309,7 @@ import { CanceledCallError } from '@ama-sdk/core';
                                         ];
                                         return [
                                             4,
-                                            _this.condition(context, undefined, e)
+                                            this.condition(context, undefined, e)
                                         ];
                                     case 5:
                                         conditionResult1 = _state.sent();
@@ -319,7 +317,7 @@ import { CanceledCallError } from '@ama-sdk/core';
                                             countDown--;
                                             return [
                                                 2,
-                                                _this.waitAndRetry(context, countDown)
+                                                this.waitAndRetry(context, countDown)
                                             ];
                                         }
                                         _state.label = 6;
@@ -331,11 +329,8 @@ import { CanceledCallError } from '@ama-sdk/core';
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }

package/esm2015/plugins/retry/retry.spec.js

@@ -120,221 +120,233 @@ function _ts_generator(thisArg, body) {
 }
 import { RetryFetch } from './retry.fetch';
 describe('Retry Fetch Plugin', function() {
-    it('should not retry on success', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runner, call, res, ret;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new RetryFetch(1, condition);
-                    runner = plugin.load({
-                        url: 'http://www.test.com',
-                        fetchPlugins: []
-                    });
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: true
-                    });
-                    res = runner.transform(call);
-                    expect(condition).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        res
-                    ];
-                case 1:
-                    ret = _state.sent();
-                    expect(ret).toEqual({
-                        text: 'test',
-                        ok: true
-                    });
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should not retry if refused by the condition', /*#__PURE__*/ _async_to_generator(function() {
-        var conditionFalsy, plugin, runner, call, res;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    conditionFalsy = jest.fn().mockReturnValue(false);
-                    plugin = new RetryFetch(3, conditionFalsy);
-                    runner = plugin.load({
-                        url: 'http://www.test.com',
-                        fetchPlugins: []
-                    });
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false,
-                        clone: function() {
-                            return {};
-                        }
-                    });
-                    res = runner.transform(call);
-                    return [
-                        4,
-                        res
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(conditionFalsy).toHaveBeenCalledTimes(1);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on fetch rejection', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new RetryFetch(2, condition);
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.reject(new Error(JSON.stringify({
-                        text: 'test',
-                        ok: true
-                    })));
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(2);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on fetch rejection with wait', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, delay, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    delay = 500;
-                    plugin = new RetryFetch(2, condition, function() {
-                        return delay;
-                    });
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.reject(new Error(JSON.stringify({
-                        text: 'test',
-                        ok: true
-                    })));
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(2);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on not ok call', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new RetryFetch(3, condition);
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(3);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on not ok call with wait', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, delay, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    delay = 500;
-                    plugin = new RetryFetch(3, condition, function() {
-                        return delay;
-                    });
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(2 * delay)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(3);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('should not retry on success', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runner, call, res, ret;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new RetryFetch(1, condition);
+                        runner = plugin.load({
+                            url: 'http://www.test.com',
+                            fetchPlugins: []
+                        });
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: true
+                        });
+                        res = runner.transform(call);
+                        expect(condition).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            res
+                        ];
+                    case 1:
+                        ret = _state.sent();
+                        expect(ret).toEqual({
+                            text: 'test',
+                            ok: true
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should not retry if refused by the condition', function() {
+        return _async_to_generator(function() {
+            var conditionFalsy, plugin, runner, call, res;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        conditionFalsy = jest.fn().mockReturnValue(false);
+                        plugin = new RetryFetch(3, conditionFalsy);
+                        runner = plugin.load({
+                            url: 'http://www.test.com',
+                            fetchPlugins: []
+                        });
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false,
+                            clone: function() {
+                                return {};
+                            }
+                        });
+                        res = runner.transform(call);
+                        return [
+                            4,
+                            res
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(conditionFalsy).toHaveBeenCalledTimes(1);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on fetch rejection', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new RetryFetch(2, condition);
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.reject(new Error(JSON.stringify({
+                            text: 'test',
+                            ok: true
+                        })));
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(2);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on fetch rejection with wait', function() {
+        return _async_to_generator(function() {
+            var condition, delay, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        delay = 500;
+                        plugin = new RetryFetch(2, condition, function() {
+                            return delay;
+                        });
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.reject(new Error(JSON.stringify({
+                            text: 'test',
+                            ok: true
+                        })));
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(2);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on not ok call', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new RetryFetch(3, condition);
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(3);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on not ok call with wait', function() {
+        return _async_to_generator(function() {
+            var condition, delay, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        delay = 500;
+                        plugin = new RetryFetch(3, condition, function() {
+                            return delay;
+                        });
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(2 * delay)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(3);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });

package/esm2015/plugins/timeout/timeout.fetch.js

@@ -231,18 +231,19 @@ import { ResponseTimeoutError } from '@ama-sdk/core';
                 return {
                     transform: function(fetchCall) {
                         return(// eslint-disable-next-line no-async-promise-executor -- all await are handled with a try-catch block
-                        new Promise(/*#__PURE__*/ function() {
-                            var _ref = _async_to_generator(function(resolve, reject) {
-                                var timeoutCallback, timer, timerCallback, response, ex;
+                        new Promise(function(resolve, reject) {
+                            return _async_to_generator(function() {
+                                var _this, timeoutCallback, timer, timerCallback, response, ex;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
+                                            _this = this;
                                             timeoutCallback = function() {
                                                 reject(new ResponseTimeoutError("in ".concat(_this.timeout, "ms")));
                                                 // Fetch abort controller is now supported by all modern browser and node 15+. It should always be defined
                                                 context.controller.abort();
                                             };
-                                            timer = _this.timerPauseState === 'timeoutStopped' ? undefined : setTimeout(timeoutCallback, _this.timeout);
+                                            timer = this.timerPauseState === 'timeoutStopped' ? undefined : setTimeout(timeoutCallback, this.timeout);
                                             timerCallback = function(pauseStatus) {
                                                 if (timer && pauseStatus === 'timeoutStopped') {
                                                     clearTimeout(timer);
@@ -253,7 +254,7 @@ import { ResponseTimeoutError } from '@ama-sdk/core';
                                                     (context.logger || console).log('[SDK Plugins] Timeout restarted.');
                                                 }
                                             };
-                                            _this.timerSubscription.push(timerCallback);
+                                            this.timerSubscription.push(timerCallback);
                                             _state.label = 1;
                                         case 1:
                                             _state.trys.push([
@@ -286,7 +287,7 @@ import { ResponseTimeoutError } from '@ama-sdk/core';
                                             if (timer) {
                                                 clearTimeout(timer);
                                             }
-                                            _this.timerSubscription = _this.timerSubscription.filter(function(callback) {
+                                            this.timerSubscription = this.timerSubscription.filter(function(callback) {
                                                 return timerCallback !== callback;
                                             });
                                             return [
@@ -298,11 +299,8 @@ import { ResponseTimeoutError } from '@ama-sdk/core';
                                             ];
                                     }
                                 });
-                            });
-                            return function(resolve, reject) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }()));
+                            }).call(_this);
+                        }));
                     }
                 };
             }