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

package/cjs/plugins/wait-for/wait-for.fetch.js

@@ -109,7 +109,7 @@ function _object_spread_props(target, source) {
     return target;
 }
 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];
@@ -117,12 +117,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) {
@@ -135,7 +131,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,
@@ -218,23 +214,23 @@ var WaitForFetch = /*#__PURE__*/ function() {
         {
             key: "load",
             value: /** @inheritDoc */ function load(context) {
-                var data;
                 var _this = this;
+                var data;
                 return {
                     // eslint-disable-next-line no-async-promise-executor -- all await are handled with a try-catch block
                     canStart: function() {
-                        return new Promise(/*#__PURE__*/ function() {
-                            var _ref = _async_to_generator(function(resolve) {
+                        return new Promise(function(resolve) {
+                            return _async_to_generator(function() {
                                 var didTimeOut, timer, canStartCondition, canStart, e;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
                                             didTimeOut = false;
-                                            if (_this.timeout) {
+                                            if (this.timeout) {
                                                 timer = setTimeout(function() {
                                                     didTimeOut = true;
                                                     resolve(false);
-                                                }, _this.timeout);
+                                                }, this.timeout);
                                             }
                                             _state.label = 1;
                                         case 1:
@@ -246,7 +242,7 @@ var WaitForFetch = /*#__PURE__*/ function() {
                                             ]);
                                             return [
                                                 4,
-                                                _this.canStartCondition(context)
+                                                this.canStartCondition(context)
                                             ];
                                         case 2:
                                             canStartCondition = _state.sent();
@@ -286,19 +282,16 @@ var WaitForFetch = /*#__PURE__*/ function() {
                                             ];
                                     }
                                 });
-                            });
-                            return function(resolve) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }());
+                            }).call(_this);
+                        });
                     },
-                    transform: /*#__PURE__*/ function() {
-                        var _ref = _async_to_generator(function(fetchCall) {
+                    transform: function(fetchCall) {
+                        return _async_to_generator(function() {
                             var response, e;
                             return _ts_generator(this, function(_state) {
                                 switch(_state.label){
                                     case 0:
-                                        if (!_this.callback) {
+                                        if (!this.callback) {
                                             return [
                                                 2,
                                                 fetchCall
@@ -318,7 +311,7 @@ var WaitForFetch = /*#__PURE__*/ function() {
                                         ];
                                     case 2:
                                         response = _state.sent();
-                                        _this.callback(_object_spread_props(_object_spread({}, context), {
+                                        this.callback(_object_spread_props(_object_spread({}, context), {
                                             data: data
                                         }), fetchCall, response);
                                         return [
@@ -327,7 +320,7 @@ var WaitForFetch = /*#__PURE__*/ function() {
                                         ];
                                     case 3:
                                         e = _state.sent();
-                                        _this.callback(_object_spread_props(_object_spread({}, context), {
+                                        this.callback(_object_spread_props(_object_spread({}, context), {
                                             data: data
                                         }), fetchCall, response);
                                         throw e;
@@ -337,11 +330,8 @@ var WaitForFetch = /*#__PURE__*/ function() {
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }

package/cjs/plugins/wait-for/wait-for.spec.js

@@ -85,7 +85,7 @@ function _object_spread_props(target, source) {
     return target;
 }
 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];
@@ -93,12 +93,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) {
@@ -111,7 +107,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,
@@ -181,203 +177,215 @@ function _ts_generator(thisArg, body) {
 }
 describe('Wait For Fetch Plugin', function() {
     var defaultContext = {};
-    it('should not start if timeout', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, canStart;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new _waitforfetch.WaitForFetch(function() {
-                        return {
-                            result: new Promise(function(resolve) {
-                                return setTimeout(function() {
-                                    return resolve(true);
-                                }, 2000);
-                            })
-                        };
-                    }, 100);
-                    runner = plugin.load(defaultContext);
-                    canStart = runner.canStart();
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        4,
-                        canStart
-                    ];
-                case 2:
-                    expect.apply(void 0, [
-                        _state.sent()
-                    ]).toBe(false);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should start if promise condition passed', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, canStart;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new _waitforfetch.WaitForFetch(function() {
-                        return {
-                            result: Promise.resolve(true)
-                        };
-                    }, 100);
-                    runner = plugin.load(defaultContext);
-                    return [
-                        4,
-                        runner.canStart()
-                    ];
-                case 1:
-                    canStart = _state.sent();
-                    expect(canStart).toBe(true);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should start if condition passed', /*#__PURE__*/ _async_to_generator(function() {
-        var plugin, runner, canStart;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    plugin = new _waitforfetch.WaitForFetch(function() {
-                        return {
-                            result: true
+    it('should not start if timeout', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, canStart;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new _waitforfetch.WaitForFetch(function() {
+                            return {
+                                result: new Promise(function(resolve) {
+                                    return setTimeout(function() {
+                                        return resolve(true);
+                                    }, 2000);
+                                })
+                            };
+                        }, 100);
+                        runner = plugin.load(defaultContext);
+                        canStart = runner.canStart();
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            canStart
+                        ];
+                    case 2:
+                        expect.apply(void 0, [
+                            _state.sent()
+                        ]).toBe(false);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should start if promise condition passed', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, canStart;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new _waitforfetch.WaitForFetch(function() {
+                            return {
+                                result: Promise.resolve(true)
+                            };
+                        }, 100);
+                        runner = plugin.load(defaultContext);
+                        return [
+                            4,
+                            runner.canStart()
+                        ];
+                    case 1:
+                        canStart = _state.sent();
+                        expect(canStart).toBe(true);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should start if condition passed', function() {
+        return _async_to_generator(function() {
+            var plugin, runner, canStart;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        plugin = new _waitforfetch.WaitForFetch(function() {
+                            return {
+                                result: true
+                            };
+                        }, 100);
+                        runner = plugin.load(defaultContext);
+                        return [
+                            4,
+                            runner.canStart()
+                        ];
+                    case 1:
+                        canStart = _state.sent();
+                        expect(canStart).toBe(true);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should call the callback function on success', function() {
+        return _async_to_generator(function() {
+            var callback, plugin, runner, response, fetchCall;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        callback = jest.fn();
+                        plugin = new _waitforfetch.WaitForFetch(function() {
+                            return {
+                                result: true
+                            };
+                        }, 100, callback);
+                        runner = plugin.load(defaultContext);
+                        response = {
+                            test: true
                         };
-                    }, 100);
-                    runner = plugin.load(defaultContext);
-                    return [
-                        4,
-                        runner.canStart()
-                    ];
-                case 1:
-                    canStart = _state.sent();
-                    expect(canStart).toBe(true);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should call the callback function on success', /*#__PURE__*/ _async_to_generator(function() {
-        var callback, plugin, runner, response, fetchCall;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    callback = jest.fn();
-                    plugin = new _waitforfetch.WaitForFetch(function() {
-                        return {
-                            result: true
+                        fetchCall = Promise.resolve(response);
+                        return [
+                            4,
+                            runner.transform(fetchCall)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining(defaultContext), fetchCall, response);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should call the callback function with the correct data', function() {
+        return _async_to_generator(function() {
+            var callback, plugin, runner, response, fetchCall;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        callback = jest.fn();
+                        plugin = new _waitforfetch.WaitForFetch(function() {
+                            return {
+                                result: true,
+                                data: 'test'
+                            };
+                        }, 100, callback);
+                        runner = plugin.load(defaultContext);
+                        response = {
+                            test: true
                         };
-                    }, 100, callback);
-                    runner = plugin.load(defaultContext);
-                    response = {
-                        test: true
-                    };
-                    fetchCall = Promise.resolve(response);
-                    return [
-                        4,
-                        runner.transform(fetchCall)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining(defaultContext), fetchCall, response);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should call the callback function with the correct data', /*#__PURE__*/ _async_to_generator(function() {
-        var callback, plugin, runner, response, fetchCall;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    callback = jest.fn();
-                    plugin = new _waitforfetch.WaitForFetch(function() {
-                        return {
-                            result: true,
+                        fetchCall = Promise.resolve(response);
+                        return [
+                            4,
+                            runner.canStart()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            runner.transform(fetchCall)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining(_object_spread_props(_object_spread({}, defaultContext), {
                             data: 'test'
+                        })), fetchCall, response);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should call the callback function on failure', function() {
+        return _async_to_generator(function() {
+            var callback, plugin, runner, response, fetchCall, e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        callback = jest.fn();
+                        plugin = new _waitforfetch.WaitForFetch(function() {
+                            return {
+                                result: true
+                            };
+                        }, 100, callback);
+                        runner = plugin.load(defaultContext);
+                        response = {
+                            test: true
                         };
-                    }, 100, callback);
-                    runner = plugin.load(defaultContext);
-                    response = {
-                        test: true
-                    };
-                    fetchCall = Promise.resolve(response);
-                    return [
-                        4,
-                        runner.canStart()
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        4,
-                        runner.transform(fetchCall)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining(_object_spread_props(_object_spread({}, defaultContext), {
-                        data: 'test'
-                    })), fetchCall, response);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should call the callback function on failure', /*#__PURE__*/ _async_to_generator(function() {
-        var callback, plugin, runner, response, fetchCall, e;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    callback = jest.fn();
-                    plugin = new _waitforfetch.WaitForFetch(function() {
-                        return {
-                            result: true
-                        };
-                    }, 100, callback);
-                    runner = plugin.load(defaultContext);
-                    response = {
-                        test: true
-                    };
-                    fetchCall = Promise.reject(new Error(JSON.stringify(response)));
-                    _state.label = 1;
-                case 1:
-                    _state.trys.push([
-                        1,
-                        3,
-                        ,
-                        4
-                    ]);
-                    return [
-                        4,
-                        runner.transform(fetchCall)
-                    ];
-                case 2:
-                    _state.sent();
-                    return [
-                        3,
-                        4
-                    ];
-                case 3:
-                    e = _state.sent();
-                    return [
-                        3,
-                        4
-                    ];
-                case 4:
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining(defaultContext), fetchCall, undefined);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+                        fetchCall = Promise.reject(new Error(JSON.stringify(response)));
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            runner.transform(fetchCall)
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        e = _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 4:
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining(defaultContext), fetchCall, undefined);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });