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

package/cjs/api-fetch-client.js

@@ -278,7 +278,6 @@ var ApiFetchClient = /*#__PURE__*/ function() {
         {
             key: "getRequestOptions",
             value: /** @inheritdoc */ function getRequestOptions(requestOptionsParameters) {
-                var _this = this;
                 return _async_to_generator(function() {
                     var opts, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, _requestOptionsParameters_api, err;
                     return _ts_generator(this, function(_state) {
@@ -288,7 +287,7 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                                     headers: new Headers((0, _core.filterUndefinedValues)(requestOptionsParameters.headers)),
                                     queryParams: (0, _core.filterUndefinedValues)(requestOptionsParameters.queryParams)
                                 });
-                                if (!_this.options.requestPlugins) return [
+                                if (!this.options.requestPlugins) return [
                                     3,
                                     8
                                 ];
@@ -301,7 +300,7 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                                     7,
                                     8
                                 ]);
-                                _iterator = _this.options.requestPlugins[Symbol.iterator]();
+                                _iterator = this.options.requestPlugins[Symbol.iterator]();
                                 _state.label = 2;
                             case 2:
                                 if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
@@ -312,7 +311,7 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                                 return [
                                     4,
                                     plugin.load({
-                                        logger: _this.options.logger,
+                                        logger: this.options.logger,
                                         apiName: (_requestOptionsParameters_api = requestOptionsParameters.api) === null || _requestOptionsParameters_api === void 0 ? void 0 : _requestOptionsParameters_api.apiName
                                     }).transform(opts)
                                 ];
@@ -358,7 +357,7 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {
@@ -401,12 +400,12 @@ var ApiFetchClient = /*#__PURE__*/ function() {
         {
             key: "processCall",
             value: function processCall(url, options, apiType, apiName, revivers, operationId) {
-                var _this = this;
                 return _async_to_generator(function() {
-                    var response, asyncResponse, root, body, exception, origin, _options_metadata, metadataSignal, controller, loadedPlugins, _loadedPlugins, canStart, isCanceledBy, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, e, reviver, replyPlugins, parsedData, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, pluginRunner, err;
+                    var _this, response, asyncResponse, root, body, exception, origin, _options_metadata, metadataSignal, controller, loadedPlugins, _loadedPlugins, canStart, isCanceledBy, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, e, reviver, replyPlugins, parsedData, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, pluginRunner, err;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
+                                _this = this;
                                 origin = options.headers.get('Origin');
                                 _state.label = 1;
                             case 1:
@@ -424,9 +423,9 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                                     return controller.abort();
                                 });
                                 loadedPlugins = [];
-                                if (_this.options.fetchPlugins) {
+                                if (this.options.fetchPlugins) {
                                     ;
-                                    (_loadedPlugins = loadedPlugins).push.apply(_loadedPlugins, _to_consumable_array(_this.options.fetchPlugins.map(function(plugin) {
+                                    (_loadedPlugins = loadedPlugins).push.apply(_loadedPlugins, _to_consumable_array(this.options.fetchPlugins.map(function(plugin) {
                                         return plugin.load({
                                             url: url,
                                             options: options,
@@ -446,7 +445,7 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                             case 2:
                                 canStart = _state.sent();
                                 isCanceledBy = canStart.indexOf(false);
-                                asyncResponse = isCanceledBy === -1 ? fetch(url, options) : Promise.reject(new _core.CanceledCallError("Is canceled by the plugin ".concat(isCanceledBy), isCanceledBy, _this.options.fetchPlugins[isCanceledBy], {
+                                asyncResponse = isCanceledBy === -1 ? fetch(url, options) : Promise.reject(new _core.CanceledCallError("Is canceled by the plugin ".concat(isCanceledBy), isCanceledBy, this.options.fetchPlugins[isCanceledBy], {
                                     apiName: apiName,
                                     operationId: operationId,
                                     url: url,
@@ -524,10 +523,10 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                                 }
                                 // eslint-disable-next-line no-console -- `console.error` is supposed to be the default value if the `options` argument is not provided, can be removed in Otter v12.
                                 reviver = (0, _core.getResponseReviver)(revivers, response, operationId, {
-                                    disableFallback: _this.options.disableFallback,
+                                    disableFallback: this.options.disableFallback,
                                     log: console.error
                                 });
-                                replyPlugins = _this.options.replyPlugins ? _this.options.replyPlugins.map(function(plugin) {
+                                replyPlugins = this.options.replyPlugins ? this.options.replyPlugins.map(function(plugin) {
                                     return plugin.load({
                                         dictionaries: root && root.dictionaries,
                                         response: response,
@@ -608,7 +607,7 @@ var ApiFetchClient = /*#__PURE__*/ function() {
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         }
     ]);

package/cjs/plugins/abort/abort.spec.js

@@ -124,77 +124,83 @@ function _ts_generator(thisArg, body) {
     }
 }
 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.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.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.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.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.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.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/cjs/plugins/concurrent/concurrent.fetch.js

@@ -195,20 +195,19 @@ var ConcurrentFetch = /*#__PURE__*/ function() {
             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([
@@ -228,11 +227,11 @@ var ConcurrentFetch = /*#__PURE__*/ function() {
                                             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
                                         ];
@@ -242,11 +241,8 @@ var ConcurrentFetch = /*#__PURE__*/ function() {
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }

package/cjs/plugins/concurrent/concurrent.spec.js

@@ -124,27 +124,29 @@ function _ts_generator(thisArg, body) {
     }
 }
 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.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.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.ConcurrentFetch(3);
         var call = new Promise(function(resolve) {
@@ -162,74 +164,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.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.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/cjs/plugins/keepalive/keepalive.request.js

@@ -221,7 +221,6 @@ var KeepaliveRequest = /*#__PURE__*/ function() {
    * 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) {
@@ -246,14 +245,14 @@ var KeepaliveRequest = /*#__PURE__*/ function() {
                                 ];
                             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
@@ -264,7 +263,7 @@ var KeepaliveRequest = /*#__PURE__*/ function() {
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {

package/cjs/plugins/keepalive/keepalive.spec.js

@@ -129,30 +129,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.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.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
+                        ];
+                }
+            });
+        })();
+    });
 });