@ama-sdk/client-fetch 12.3.0-prerelease.9 → 12.4.0-prerelease.0

package/cjs/plugins/timeout/timeout.fetch.js

@@ -90,7 +90,7 @@ function _type_of(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 function _ts_generator(thisArg, body) {
-    var f, y, t, g, _ = {
+    var f, y, t, _ = {
         label: 0,
         sent: function() {
             if (t[0] & 1) throw t[1];
@@ -98,12 +98,8 @@ function _ts_generator(thisArg, body) {
         },
         trys: [],
         ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
         return this;
     }), g;
     function verb(n) {
@@ -116,7 +112,7 @@ function _ts_generator(thisArg, body) {
     }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while(_)try {
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [
                 op[0] & 2,
@@ -246,18 +242,19 @@ var TimeoutFetch = /*#__PURE__*/ function() {
                 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 _core.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);
@@ -268,7 +265,7 @@ var TimeoutFetch = /*#__PURE__*/ function() {
                                                     (context.logger || console).log('[SDK Plugins] Timeout restarted.');
                                                 }
                                             };
-                                            _this.timerSubscription.push(timerCallback);
+                                            this.timerSubscription.push(timerCallback);
                                             _state.label = 1;
                                         case 1:
                                             _state.trys.push([
@@ -301,7 +298,7 @@ var TimeoutFetch = /*#__PURE__*/ function() {
                                             if (timer) {
                                                 clearTimeout(timer);
                                             }
-                                            _this.timerSubscription = _this.timerSubscription.filter(function(callback) {
+                                            this.timerSubscription = this.timerSubscription.filter(function(callback) {
                                                 return timerCallback !== callback;
                                             });
                                             return [
@@ -313,11 +310,8 @@ var TimeoutFetch = /*#__PURE__*/ function() {
                                             ];
                                     }
                                 });
-                            });
-                            return function(resolve, reject) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }()));
+                            }).call(_this);
+                        }));
                     }
                 };
             }

package/cjs/plugins/timeout/timeout.spec.js

@@ -38,7 +38,7 @@ function _type_of(obj) {
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 function _ts_generator(thisArg, body) {
-    var f, y, t, g, _ = {
+    var f, y, t, _ = {
         label: 0,
         sent: function() {
             if (t[0] & 1) throw t[1];
@@ -46,12 +46,8 @@ function _ts_generator(thisArg, body) {
         },
         trys: [],
         ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
         return this;
     }), g;
     function verb(n) {
@@ -64,7 +60,7 @@ function _ts_generator(thisArg, body) {
     }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while(_)try {
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [
                 op[0] & 2,
@@ -134,203 +130,213 @@ function _ts_generator(thisArg, body) {
 }
 var _this = void 0;
 describe('Timeout Fetch Plugin', function() {
-    it('should reject on timeout', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new _timeoutfetch.TimeoutFetch(100);
-                    runner = plugin.load({
-                        controller: new AbortController()
-                    });
-                    call = new Promise(function(resolve) {
-                        return setTimeout(function() {
-                            return resolve(undefined);
-                        }, 1000);
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(99)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(1)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(new _core.ResponseTimeoutError('in 100ms'));
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should not reject on fetch rejection', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new _timeoutfetch.TimeoutFetch(6000);
-                    runner = plugin.load({
-                        controller: new AbortController()
-                    });
-                    call = new Promise(function(_resolve, reject) {
-                        return setTimeout(function() {
-                            return reject(new _core.EmptyResponseError(''));
-                        }, 100);
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(6000)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(new _core.EmptyResponseError(''));
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should forward the fetch response', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, call, promise;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new _timeoutfetch.TimeoutFetch(2000);
-                    runner = plugin.load({
-                        controller: new AbortController()
-                    });
-                    call = new Promise(function(resolve) {
-                        return setTimeout(function() {
-                            return resolve({
-                                test: true
-                            });
-                        }, 100);
-                    });
-                    promise = runner.transform(call);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        4,
-                        promise
-                    ];
-                case 2:
-                    expect.apply(void 0, [
-                        _state.sent()
-                    ]).toEqual({
-                        test: true
-                    });
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should not reject if the timeout has been paused and reject if restarted', /*#__PURE__*/ _async_to_generator(function() {
-        var timeoutPauseEvent, plugin, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    timeoutPauseEvent = {
-                        emitEvent: function(_status) {},
-                        handler: function(timeoutPauseCallback) {
-                            timeoutPauseEvent.emitEvent = timeoutPauseCallback;
-                            return function() {};
-                        }
-                    };
-                    plugin = new _timeoutfetch.TimeoutFetch(100, timeoutPauseEvent.handler);
-                    runner = plugin.load({
-                        controller: new AbortController()
-                    });
-                    call = new Promise(function(resolve) {
-                        return setTimeout(function() {
-                            return resolve({
-                                test: true
-                            });
-                        }, 500);
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    timeoutPauseEvent.emitEvent('timeoutStopped');
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(200)
-                    ];
-                case 1:
-                    _state.sent();
-                    timeoutPauseEvent.emitEvent('timeoutStarted');
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(200)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(new _core.ResponseTimeoutError('in 100ms'));
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should take into account pause events triggered before the call', /*#__PURE__*/ _async_to_generator(function() {
-        var timeoutPauseEvent, plugin, runner, call, promise;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    timeoutPauseEvent = {
-                        emitEvent: function(_status) {},
-                        handler: function(timeoutPauseCallback) {
-                            timeoutPauseEvent.emitEvent = timeoutPauseCallback;
-                            return function() {};
-                        }
-                    };
-                    plugin = new _timeoutfetch.TimeoutFetch(250, timeoutPauseEvent.handler);
-                    runner = plugin.load({
-                        controller: new AbortController()
-                    });
-                    call = new Promise(function(resolve) {
-                        return setTimeout(function() {
-                            return resolve({
-                                test: true
-                            });
-                        }, 500);
-                    });
-                    timeoutPauseEvent.emitEvent('timeoutStopped');
-                    promise = runner.transform(call);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        4,
-                        promise
-                    ];
-                case 2:
-                    expect.apply(void 0, [
-                        _state.sent()
-                    ]).toEqual({
-                        test: true
-                    });
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('should reject on timeout', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new _timeoutfetch.TimeoutFetch(100);
+                        runner = plugin.load({
+                            controller: new AbortController()
+                        });
+                        call = new Promise(function(resolve) {
+                            return setTimeout(function() {
+                                return resolve(undefined);
+                            }, 1000);
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(99)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(1)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(new _core.ResponseTimeoutError('in 100ms'));
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should not reject on fetch rejection', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new _timeoutfetch.TimeoutFetch(6000);
+                        runner = plugin.load({
+                            controller: new AbortController()
+                        });
+                        call = new Promise(function(_resolve, reject) {
+                            return setTimeout(function() {
+                                return reject(new _core.EmptyResponseError(''));
+                            }, 100);
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(6000)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(new _core.EmptyResponseError(''));
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should forward the fetch response', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, call, promise;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new _timeoutfetch.TimeoutFetch(2000);
+                        runner = plugin.load({
+                            controller: new AbortController()
+                        });
+                        call = new Promise(function(resolve) {
+                            return setTimeout(function() {
+                                return resolve({
+                                    test: true
+                                });
+                            }, 100);
+                        });
+                        promise = runner.transform(call);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            promise
+                        ];
+                    case 2:
+                        expect.apply(void 0, [
+                            _state.sent()
+                        ]).toEqual({
+                            test: true
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should not reject if the timeout has been paused and reject if restarted', function() {
+        return _async_to_generator(function() {
+            var timeoutPauseEvent, plugin, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        timeoutPauseEvent = {
+                            emitEvent: function(_status) {},
+                            handler: function(timeoutPauseCallback) {
+                                timeoutPauseEvent.emitEvent = timeoutPauseCallback;
+                                return function() {};
+                            }
+                        };
+                        plugin = new _timeoutfetch.TimeoutFetch(100, timeoutPauseEvent.handler);
+                        runner = plugin.load({
+                            controller: new AbortController()
+                        });
+                        call = new Promise(function(resolve) {
+                            return setTimeout(function() {
+                                return resolve({
+                                    test: true
+                                });
+                            }, 500);
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        timeoutPauseEvent.emitEvent('timeoutStopped');
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(200)
+                        ];
+                    case 1:
+                        _state.sent();
+                        timeoutPauseEvent.emitEvent('timeoutStarted');
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(200)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(new _core.ResponseTimeoutError('in 100ms'));
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should take into account pause events triggered before the call', function() {
+        return _async_to_generator(function() {
+            var timeoutPauseEvent, plugin, runner, call, promise;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        timeoutPauseEvent = {
+                            emitEvent: function(_status) {},
+                            handler: function(timeoutPauseCallback) {
+                                timeoutPauseEvent.emitEvent = timeoutPauseCallback;
+                                return function() {};
+                            }
+                        };
+                        plugin = new _timeoutfetch.TimeoutFetch(250, timeoutPauseEvent.handler);
+                        runner = plugin.load({
+                            controller: new AbortController()
+                        });
+                        call = new Promise(function(resolve) {
+                            return setTimeout(function() {
+                                return resolve({
+                                    test: true
+                                });
+                            }, 500);
+                        });
+                        timeoutPauseEvent.emitEvent('timeoutStopped');
+                        promise = runner.transform(call);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            promise
+                        ];
+                    case 2:
+                        expect.apply(void 0, [
+                            _state.sent()
+                        ]).toEqual({
+                            test: true
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });
 describe('impervaCaptchaEventHandlerFactory', function() {
     var postMessageTemp;