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

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

@@ -179,22 +179,22 @@ var MockInterceptFetch = /*#__PURE__*/ function() {
         {
             key: "load",
             value: function load(context) {
+                var _this = this;
                 if (!context.apiClient.options.requestPlugins.some(function(plugin) {
                     return _instanceof(plugin, _core.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();
@@ -205,15 +205,15 @@ var MockInterceptFetch = /*#__PURE__*/ function() {
                                                 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
@@ -221,7 +221,7 @@ var MockInterceptFetch = /*#__PURE__*/ function() {
                                     case 2:
                                         return [
                                             4,
-                                            _this.options.delayTiming(context)
+                                            this.options.delayTiming(context)
                                         ];
                                     case 3:
                                         _tmp = _state.sent();
@@ -243,7 +243,7 @@ var MockInterceptFetch = /*#__PURE__*/ function() {
                                     case 6:
                                         operationId = context.options.headers.get(_core.CUSTOM_MOCK_OPERATION_ID_HEADER);
                                         try {
-                                            mock = _this.options.adapter.getLatestMock(operationId);
+                                            mock = this.options.adapter.getLatestMock(operationId);
                                             if (!mock.getResponse) {
                                                 return [
                                                     2,
@@ -269,11 +269,8 @@ var MockInterceptFetch = /*#__PURE__*/ function() {
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }

package/cjs/plugins/mock-intercept/mock-intercept.spec.js

@@ -167,113 +167,119 @@ describe('Mock intercept', function() {
         return jest.clearAllMocks();
     });
     describe('request plugin', function() {
-        it('should do nothing if disabled is true', /*#__PURE__*/ _async_to_generator(function() {
-            var plugin, originalRequest, loaded;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        plugin = new _core.MockInterceptRequest({
-                            disabled: true,
-                            adapter: testMockAdapter
-                        });
-                        originalRequest = {
-                            method: 'get',
-                            headers: new Headers({
-                                test: 'true'
-                            }),
-                            basePath: 'myurl'
-                        };
-                        loaded = plugin.load();
-                        return [
-                            4,
-                            loaded.transform(originalRequest)
-                        ];
-                    case 1:
-                        expect.apply(void 0, [
-                            _state.sent()
-                        ]).toEqual(originalRequest);
-                        expect(initializeSpy).toHaveBeenCalled();
-                        return [
-                            2
-                        ];
-                }
-            });
-        }));
-        it('should not stringify provided api', /*#__PURE__*/ _async_to_generator(function() {
-            var plugin, loaded, originalRequest;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        plugin = new _core.MockInterceptRequest({
-                            disabled: false,
-                            adapter: testMockAdapter
-                        });
-                        loaded = plugin.load();
-                        originalRequest = {
-                            method: 'get',
-                            headers: new Headers({
-                                test: 'true'
-                            }),
-                            basePath: 'myurl',
-                            api: 'should not exist'
-                        };
-                        return [
-                            4,
-                            loaded.transform(originalRequest)
-                        ];
-                    case 1:
-                        _state.sent();
-                        expect(originalRequest.headers.has(_core.CUSTOM_MOCK_REQUEST_HEADER)).toBe(true);
-                        expect(Object.keys(JSON.parse(originalRequest.headers.get(_core.CUSTOM_MOCK_REQUEST_HEADER)))).not.toContainEqual('api');
-                        return [
-                            2
-                        ];
-                }
-            });
-        }));
-        it('should intercept the request', /*#__PURE__*/ _async_to_generator(function() {
-            var plugin, originalRequest, loaded, transformed, res;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        // Disabled because Blob URL is not supported on NodeJS
-                        plugin = new _core.MockInterceptRequest({
-                            adapter: testMockAdapter
-                        });
-                        originalRequest = {
-                            headers: new Headers({
-                                test: 'true'
-                            }),
-                            basePath: 'myurl',
-                            method: 'PATCH'
-                        };
-                        loaded = plugin.load();
-                        return [
-                            4,
-                            loaded.transform(originalRequest)
-                        ];
-                    case 1:
-                        transformed = _state.sent();
-                        return [
-                            4,
-                            fetch(transformed.basePath, transformed)
-                        ];
-                    case 2:
-                        return [
-                            4,
-                            _state.sent().text()
-                        ];
-                    case 3:
-                        res = _state.sent();
-                        expect(getMockSpy).toHaveBeenCalled();
-                        expect(res).toBe(JSON.stringify(testMock.mockData));
-                        expect(initializeSpy).toHaveBeenCalled();
-                        return [
-                            2
-                        ];
-                }
-            });
-        }));
+        it('should do nothing if disabled is true', function() {
+            return _async_to_generator(function() {
+                var plugin, originalRequest, loaded;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            plugin = new _core.MockInterceptRequest({
+                                disabled: true,
+                                adapter: testMockAdapter
+                            });
+                            originalRequest = {
+                                method: 'get',
+                                headers: new Headers({
+                                    test: 'true'
+                                }),
+                                basePath: 'myurl'
+                            };
+                            loaded = plugin.load();
+                            return [
+                                4,
+                                loaded.transform(originalRequest)
+                            ];
+                        case 1:
+                            expect.apply(void 0, [
+                                _state.sent()
+                            ]).toEqual(originalRequest);
+                            expect(initializeSpy).toHaveBeenCalled();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should not stringify provided api', function() {
+            return _async_to_generator(function() {
+                var plugin, loaded, originalRequest;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            plugin = new _core.MockInterceptRequest({
+                                disabled: false,
+                                adapter: testMockAdapter
+                            });
+                            loaded = plugin.load();
+                            originalRequest = {
+                                method: 'get',
+                                headers: new Headers({
+                                    test: 'true'
+                                }),
+                                basePath: 'myurl',
+                                api: 'should not exist'
+                            };
+                            return [
+                                4,
+                                loaded.transform(originalRequest)
+                            ];
+                        case 1:
+                            _state.sent();
+                            expect(originalRequest.headers.has(_core.CUSTOM_MOCK_REQUEST_HEADER)).toBe(true);
+                            expect(Object.keys(JSON.parse(originalRequest.headers.get(_core.CUSTOM_MOCK_REQUEST_HEADER)))).not.toContainEqual('api');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should intercept the request', function() {
+            return _async_to_generator(function() {
+                var plugin, originalRequest, loaded, transformed, res;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Disabled because Blob URL is not supported on NodeJS
+                            plugin = new _core.MockInterceptRequest({
+                                adapter: testMockAdapter
+                            });
+                            originalRequest = {
+                                headers: new Headers({
+                                    test: 'true'
+                                }),
+                                basePath: 'myurl',
+                                method: 'PATCH'
+                            };
+                            loaded = plugin.load();
+                            return [
+                                4,
+                                loaded.transform(originalRequest)
+                            ];
+                        case 1:
+                            transformed = _state.sent();
+                            return [
+                                4,
+                                fetch(transformed.basePath, transformed)
+                            ];
+                        case 2:
+                            return [
+                                4,
+                                _state.sent().text()
+                            ];
+                        case 3:
+                            res = _state.sent();
+                            expect(getMockSpy).toHaveBeenCalled();
+                            expect(res).toBe(JSON.stringify(testMock.mockData));
+                            expect(initializeSpy).toHaveBeenCalled();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
     });
     describe('fetch plugin', function() {
         describe('when using an initialization function', function() {
@@ -290,152 +296,158 @@ describe('Mock intercept', function() {
                     adapter: asyncMockAdapter
                 });
             });
-            it('should call initialize fn', /*#__PURE__*/ _async_to_generator(function() {
-                var loadedPlugin, testData;
+            it('should call initialize fn', function() {
+                return _async_to_generator(function() {
+                    var loadedPlugin, testData;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                loadedPlugin = plugin.load({
+                                    controller: jest.fn(),
+                                    fetchPlugins: [],
+                                    url: 'myurl',
+                                    apiClient: apiClient,
+                                    options: {
+                                        headers: new Headers(_define_property({}, _core.CUSTOM_MOCK_OPERATION_ID_HEADER, 'testOperation'))
+                                    }
+                                });
+                                testData = {
+                                    test: true
+                                };
+                                return [
+                                    4,
+                                    loadedPlugin.transform(Promise.resolve(testData))
+                                ];
+                            case 1:
+                                _state.sent();
+                                expect(initializeSpy).toHaveBeenCalled();
+                                expect(getMockSpy).not.toHaveBeenCalled();
+                                expect(getLatestMockSpy).toHaveBeenCalledWith('testOperation');
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            });
+            it('should throw if there is no request plugin', function() {
+                var config = {
+                    controller: jest.fn(),
+                    fetchPlugins: [],
+                    url: 'myurl',
+                    apiClient: {
+                        options: {
+                            requestPlugins: []
+                        }
+                    },
+                    options: {
+                        headers: new Headers(_define_property({}, _core.CUSTOM_MOCK_OPERATION_ID_HEADER, 'testOperation'))
+                    }
+                };
+                expect(function() {
+                    return plugin.load(config);
+                }).toThrow();
+            });
+        });
+    });
+    describe('with delay', function() {
+        it('should delay the response of the specific number', function() {
+            return _async_to_generator(function() {
+                var plugin, loadedPlugin, callback, run;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
+                            plugin = new _mockinterceptfetch.MockInterceptFetch({
+                                adapter: testMockAdapter,
+                                delayTiming: 700
+                            });
                             loadedPlugin = plugin.load({
                                 controller: jest.fn(),
                                 fetchPlugins: [],
-                                url: 'myurl',
+                                url: '',
                                 apiClient: apiClient,
                                 options: {
                                     headers: new Headers(_define_property({}, _core.CUSTOM_MOCK_OPERATION_ID_HEADER, 'testOperation'))
                                 }
                             });
-                            testData = {
-                                test: true
-                            };
+                            callback = jest.fn();
+                            run = loadedPlugin.transform(Promise.resolve({})).then(callback);
                             return [
                                 4,
-                                loadedPlugin.transform(Promise.resolve(testData))
+                                jest.advanceTimersByTimeAsync(699)
                             ];
                         case 1:
                             _state.sent();
-                            expect(initializeSpy).toHaveBeenCalled();
-                            expect(getMockSpy).not.toHaveBeenCalled();
-                            expect(getLatestMockSpy).toHaveBeenCalledWith('testOperation');
+                            expect(callback).not.toHaveBeenCalled();
+                            return [
+                                4,
+                                jest.advanceTimersByTimeAsync(1)
+                            ];
+                        case 2:
+                            _state.sent();
+                            expect(callback).toHaveBeenCalled();
+                            return [
+                                4,
+                                run
+                            ];
+                        case 3:
+                            _state.sent();
                             return [
                                 2
                             ];
                     }
                 });
-            }));
-            it('should throw if there is no request plugin', function() {
-                var config = {
-                    controller: jest.fn(),
-                    fetchPlugins: [],
-                    url: 'myurl',
-                    apiClient: {
-                        options: {
-                            requestPlugins: []
-                        }
-                    },
-                    options: {
-                        headers: new Headers(_define_property({}, _core.CUSTOM_MOCK_OPERATION_ID_HEADER, 'testOperation'))
+            })();
+        });
+        it('should delay the response based on callback', function() {
+            return _async_to_generator(function() {
+                var plugin, loadedPlugin, callback, run;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            plugin = new _mockinterceptfetch.MockInterceptFetch({
+                                adapter: testMockAdapter,
+                                delayTiming: function() {
+                                    return 800;
+                                }
+                            });
+                            loadedPlugin = plugin.load({
+                                controller: jest.fn(),
+                                fetchPlugins: [],
+                                url: '',
+                                apiClient: apiClient,
+                                options: {
+                                    headers: new Headers(_define_property({}, _core.CUSTOM_MOCK_OPERATION_ID_HEADER, 'testOperation'))
+                                }
+                            });
+                            callback = jest.fn();
+                            run = loadedPlugin.transform(Promise.resolve({})).then(callback);
+                            return [
+                                4,
+                                jest.advanceTimersByTimeAsync(799)
+                            ];
+                        case 1:
+                            _state.sent();
+                            expect(callback).not.toHaveBeenCalled();
+                            return [
+                                4,
+                                jest.advanceTimersByTimeAsync(1)
+                            ];
+                        case 2:
+                            _state.sent();
+                            expect(callback).toHaveBeenCalled();
+                            return [
+                                4,
+                                run
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                2
+                            ];
                     }
-                };
-                expect(function() {
-                    return plugin.load(config);
-                }).toThrow();
-            });
+                });
+            })();
         });
     });
-    describe('with delay', function() {
-        it('should delay the response of the specific number', /*#__PURE__*/ _async_to_generator(function() {
-            var plugin, loadedPlugin, callback, run;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        plugin = new _mockinterceptfetch.MockInterceptFetch({
-                            adapter: testMockAdapter,
-                            delayTiming: 700
-                        });
-                        loadedPlugin = plugin.load({
-                            controller: jest.fn(),
-                            fetchPlugins: [],
-                            url: '',
-                            apiClient: apiClient,
-                            options: {
-                                headers: new Headers(_define_property({}, _core.CUSTOM_MOCK_OPERATION_ID_HEADER, 'testOperation'))
-                            }
-                        });
-                        callback = jest.fn();
-                        run = loadedPlugin.transform(Promise.resolve({})).then(callback);
-                        return [
-                            4,
-                            jest.advanceTimersByTimeAsync(699)
-                        ];
-                    case 1:
-                        _state.sent();
-                        expect(callback).not.toHaveBeenCalled();
-                        return [
-                            4,
-                            jest.advanceTimersByTimeAsync(1)
-                        ];
-                    case 2:
-                        _state.sent();
-                        expect(callback).toHaveBeenCalled();
-                        return [
-                            4,
-                            run
-                        ];
-                    case 3:
-                        _state.sent();
-                        return [
-                            2
-                        ];
-                }
-            });
-        }));
-        it('should delay the response based on callback', /*#__PURE__*/ _async_to_generator(function() {
-            var plugin, loadedPlugin, callback, run;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        plugin = new _mockinterceptfetch.MockInterceptFetch({
-                            adapter: testMockAdapter,
-                            delayTiming: function() {
-                                return 800;
-                            }
-                        });
-                        loadedPlugin = plugin.load({
-                            controller: jest.fn(),
-                            fetchPlugins: [],
-                            url: '',
-                            apiClient: apiClient,
-                            options: {
-                                headers: new Headers(_define_property({}, _core.CUSTOM_MOCK_OPERATION_ID_HEADER, 'testOperation'))
-                            }
-                        });
-                        callback = jest.fn();
-                        run = loadedPlugin.transform(Promise.resolve({})).then(callback);
-                        return [
-                            4,
-                            jest.advanceTimersByTimeAsync(799)
-                        ];
-                    case 1:
-                        _state.sent();
-                        expect(callback).not.toHaveBeenCalled();
-                        return [
-                            4,
-                            jest.advanceTimersByTimeAsync(1)
-                        ];
-                    case 2:
-                        _state.sent();
-                        expect(callback).toHaveBeenCalled();
-                        return [
-                            4,
-                            run
-                        ];
-                    case 3:
-                        _state.sent();
-                        return [
-                            2
-                        ];
-                }
-            });
-        }));
-    });
 });

package/cjs/plugins/perf-metric/perf-metric.fetch.js

@@ -318,13 +318,13 @@ var PerformanceMetricPlugin = /*#__PURE__*/ function() {
             value: /** @inheritDoc */ function load(context) {
                 var _this = this;
                 return {
-                    transform: /*#__PURE__*/ function() {
-                        var _ref = _async_to_generator(function(fetchCall) {
+                    transform: function(fetchCall) {
+                        return _async_to_generator(function() {
                             var markId, response, exception;
                             return _ts_generator(this, function(_state) {
                                 switch(_state.label){
                                     case 0:
-                                        markId = _this.openMark(context.url, context.options);
+                                        markId = this.openMark(context.url, context.options);
                                         _state.label = 1;
                                     case 1:
                                         _state.trys.push([
@@ -339,14 +339,14 @@ var PerformanceMetricPlugin = /*#__PURE__*/ function() {
                                         ];
                                     case 2:
                                         response = _state.sent();
-                                        _this.closeMark(markId, response);
+                                        this.closeMark(markId, response);
                                         return [
                                             2,
                                             response
                                         ];
                                     case 3:
                                         exception = _state.sent();
-                                        _this.closeMarkWithError(markId, exception);
+                                        this.closeMarkWithError(markId, exception);
                                         throw exception;
                                     case 4:
                                         return [
@@ -354,11 +354,8 @@ var PerformanceMetricPlugin = /*#__PURE__*/ function() {
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }