@lowdefy/engine 3.23.0 → 4.0.0-alpha.5

package/dist/Actions.js

@@ -1,330 +1,241 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
-var _index = _interopRequireDefault(require("./actions/index.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-class Actions {
-  constructor(context) {
-    this.context = context;
-    this.callAction = this.callAction.bind(this);
-    this.callActionLoop = this.callActionLoop.bind(this);
-    this.callActions = this.callActions.bind(this);
-    this.displayMessage = this.displayMessage.bind(this);
-    this.actions = _index.default;
-  }
-
-  callAsyncAction(_ref) {
-    var _this = this;
-
-    return _asyncToGenerator(function* () {
-      var {
-        action,
-        arrayIndices,
-        block,
-        event,
-        index,
-        responses
-      } = _ref;
-
-      try {
-        var response = yield _this.callAction({
-          action,
-          arrayIndices,
-          block,
-          event,
-          index,
-          responses
-        });
-        responses[action.id] = response;
-      } catch (error) {
-        responses[action.id] = error;
-        console.error(error);
-      }
-    })();
-  }
-
-  callActionLoop(_ref2) {
-    var _this2 = this;
-
-    return _asyncToGenerator(function* () {
-      var {
-        actions,
-        arrayIndices,
-        block,
-        event,
-        responses
-      } = _ref2;
-
-      for (var [index, action] of actions.entries()) {
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+import actions from './actions/index.js';
+let Actions = class Actions {
+    async callAsyncAction({ action , arrayIndices , block , event , index , responses  }) {
         try {
-          if (action.async === true) {
-            _this2.callAsyncAction({
-              action,
-              arrayIndices,
-              block,
-              event,
-              index,
-              responses
-            });
-          } else {
-            var response = yield _this2.callAction({
-              action,
-              arrayIndices,
-              block,
-              event,
-              index,
-              responses
+            const response = await this.callAction({
+                action,
+                arrayIndices,
+                block,
+                event,
+                index,
+                responses
             });
             responses[action.id] = response;
-          }
         } catch (error) {
-          responses[action.id] = error;
-          throw {
-            error,
-            action
-          };
+            responses[action.id] = error;
+            console.error(error);
         }
-      }
-    })();
-  }
-
-  callActions(_ref3) {
-    var _this3 = this;
-
-    return _asyncToGenerator(function* () {
-      var {
-        actions,
-        arrayIndices,
-        block,
-        catchActions,
-        event,
-        eventName
-      } = _ref3;
-      var startTimestamp = new Date();
-      var responses = {};
-
-      try {
-        yield _this3.callActionLoop({
-          actions,
-          arrayIndices,
-          block,
-          event,
-          responses
-        });
-      } catch (error) {
-        console.error(error);
-
+    }
+    async callActionLoop({ actions: actions1 , arrayIndices: arrayIndices1 , block: block1 , event: event1 , responses: responses1  }) {
+        for (const [index, action] of actions1.entries()){
+            try {
+                if (action.async === true) {
+                    this.callAsyncAction({
+                        action,
+                        arrayIndices: arrayIndices1,
+                        block: block1,
+                        event: event1,
+                        index,
+                        responses: responses1
+                    });
+                } else {
+                    const response = await this.callAction({
+                        action,
+                        arrayIndices: arrayIndices1,
+                        block: block1,
+                        event: event1,
+                        index,
+                        responses: responses1
+                    });
+                    responses1[action.id] = response;
+                }
+            } catch (error) {
+                responses1[action.id] = error;
+                throw {
+                    error,
+                    action
+                };
+            }
+        }
+    }
+    async callActions({ actions: actions2 , arrayIndices: arrayIndices2 , block: block2 , catchActions , event: event2 , eventName  }) {
+        const startTimestamp = new Date();
+        const responses = {
+        };
         try {
-          yield _this3.callActionLoop({
-            actions: catchActions,
-            arrayIndices,
-            block,
-            event,
-            responses
-          });
-        } catch (errorCatch) {
-          console.error(errorCatch);
-          return {
-            blockId: block.blockId,
+            await this.callActionLoop({
+                actions: actions2,
+                arrayIndices: arrayIndices2,
+                block: block2,
+                event: event2,
+                responses
+            });
+        } catch (error) {
+            console.error(error);
+            try {
+                await this.callActionLoop({
+                    actions: catchActions,
+                    arrayIndices: arrayIndices2,
+                    block: block2,
+                    event: event2,
+                    responses
+                });
+            } catch (errorCatch) {
+                console.error(errorCatch);
+                return {
+                    blockId: block2.blockId,
+                    bounced: false,
+                    endTimestamp: new Date(),
+                    error,
+                    errorCatch,
+                    event: event2,
+                    eventName,
+                    responses,
+                    startTimestamp,
+                    success: false
+                };
+            }
+            return {
+                blockId: block2.blockId,
+                bounced: false,
+                endTimestamp: new Date(),
+                error,
+                event: event2,
+                eventName,
+                responses,
+                startTimestamp,
+                success: false
+            };
+        }
+        return {
+            blockId: block2.blockId,
             bounced: false,
             endTimestamp: new Date(),
-            error,
-            errorCatch,
-            event,
+            event: event2,
             eventName,
             responses,
             startTimestamp,
-            success: false
-          };
-        }
-
-        return {
-          blockId: block.blockId,
-          bounced: false,
-          endTimestamp: new Date(),
-          error,
-          event,
-          eventName,
-          responses,
-          startTimestamp,
-          success: false
+            success: true
         };
-      }
-
-      return {
-        blockId: block.blockId,
-        bounced: false,
-        endTimestamp: new Date(),
-        event,
-        eventName,
-        responses,
-        startTimestamp,
-        success: true
-      };
-    })();
-  }
-
-  callAction(_ref4) {
-    var _this4 = this;
-
-    return _asyncToGenerator(function* () {
-      var {
-        action,
-        arrayIndices,
-        block,
-        event,
-        index,
-        responses
-      } = _ref4;
-
-      if (!_index.default[action.type]) {
-        throw {
-          error: new Error("Invalid action type \"".concat(action.type, "\" at \"").concat(block.blockId, "\".")),
-          type: action.type,
-          index
-        };
-      }
-
-      var {
-        output: parsedAction,
-        errors: parserErrors
-      } = _this4.context.parser.parse({
-        actions: responses,
-        event,
-        arrayIndices,
-        input: action,
-        location: block.blockId
-      });
-
-      if (parserErrors.length > 0) {
-        throw {
-          error: parserErrors[0],
-          type: action.type,
-          index
-        };
-      }
-
-      if (parsedAction.skip === true) {
-        return {
-          type: action.type,
-          skipped: true,
-          index
-        };
-      }
-
-      var messages = parsedAction.messages || {};
-      var response;
-
-      var closeLoading = _this4.displayMessage({
-        defaultMessage: 'Loading',
-        duration: 0,
-        message: messages.loading,
-        status: 'loading'
-      });
-
-      try {
-        response = yield _index.default[action.type]({
-          arrayIndices,
-          blockId: block.blockId,
-          context: _this4.context,
-          event,
-          params: parsedAction.params
+    }
+    async callAction({ action: action1 , arrayIndices: arrayIndices3 , block: block3 , event: event3 , index: index1 , responses: responses2  }) {
+        if (!actions[action1.type]) {
+            throw {
+                error: new Error(`Invalid action type "${action1.type}" at "${block3.blockId}".`),
+                type: action1.type,
+                index: index1
+            };
+        }
+        const { output: parsedAction , errors: parserErrors  } = this.context._internal.parser.parse({
+            actions: responses2,
+            event: event3,
+            arrayIndices: arrayIndices3,
+            input: action1,
+            location: block3.blockId
         });
-      } catch (error) {
-        responses[action.id] = {
-          error,
-          index,
-          type: action.type
+        if (parserErrors.length > 0) {
+            throw {
+                error: parserErrors[0],
+                type: action1.type,
+                index: index1
+            };
+        }
+        if (parsedAction.skip === true) {
+            return {
+                type: action1.type,
+                skipped: true,
+                index: index1
+            };
+        }
+        const messages = parsedAction.messages || {
         };
-
-        var {
-          output: parsedMessages,
-          errors: _parserErrors
-        } = _this4.context.parser.parse({
-          actions: responses,
-          event,
-          arrayIndices,
-          input: action.messages,
-          location: block.blockId
+        let response;
+        const closeLoading = this.displayMessage({
+            defaultMessage: 'Loading',
+            duration: 0,
+            message: messages.loading,
+            status: 'loading'
         });
-
-        if (_parserErrors.length > 0) {
-          // this condition is very unlikely since parser errors usually occur in the first parse.
-          throw {
-            error: _parserErrors[0],
-            type: action.type,
-            index
-          };
+        try {
+            response = await actions[action1.type]({
+                arrayIndices: arrayIndices3,
+                blockId: block3.blockId,
+                context: this.context,
+                event: event3,
+                params: parsedAction.params
+            });
+        } catch (error) {
+            responses2[action1.id] = {
+                error,
+                index: index1,
+                type: action1.type
+            };
+            const { output: parsedMessages , errors: parserErrors  } = this.context._internal.parser.parse({
+                actions: responses2,
+                event: event3,
+                arrayIndices: arrayIndices3,
+                input: action1.messages,
+                location: block3.blockId
+            });
+            if (parserErrors.length > 0) {
+                // this condition is very unlikely since parser errors usually occur in the first parse.
+                throw {
+                    error: parserErrors[0],
+                    type: action1.type,
+                    index: index1
+                };
+            }
+            closeLoading();
+            this.displayMessage({
+                defaultMessage: error.message,
+                duration: 6,
+                hideExplicitly: true,
+                message: (parsedMessages || {
+                }).error,
+                status: 'error'
+            });
+            throw {
+                type: action1.type,
+                error,
+                index: index1
+            };
         }
-
         closeLoading();
-
-        _this4.displayMessage({
-          defaultMessage: error.message,
-          duration: 6,
-          hideExplicitly: true,
-          message: (parsedMessages || {}).error,
-          status: 'error'
+        this.displayMessage({
+            defaultMessage: 'Success',
+            message: messages.success,
+            status: 'success'
         });
-
-        throw {
-          type: action.type,
-          error,
-          index
+        return {
+            type: action1.type,
+            response,
+            index: index1
         };
-      }
-
-      closeLoading();
-
-      _this4.displayMessage({
-        defaultMessage: 'Success',
-        message: messages.success,
-        status: 'success'
-      });
-
-      return {
-        type: action.type,
-        response,
-        index
-      };
-    })();
-  }
-
-  displayMessage(_ref5) {
-    var {
-      defaultMessage,
-      duration,
-      hideExplicitly,
-      message,
-      status
-    } = _ref5;
-
-    var close = () => undefined;
-
-    if (hideExplicitly && message !== false || !hideExplicitly && !_helpers.type.isNone(message)) {
-      close = this.context.lowdefy.displayMessage({
-        content: _helpers.type.isString(message) ? message : defaultMessage,
-        duration,
-        status
-      });
     }
-
-    return close;
-  }
-
-}
-
-var _default = Actions;
-exports.default = _default;
+    displayMessage({ defaultMessage , duration , hideExplicitly , message , status  }) {
+        let close = ()=>undefined
+        ;
+        if (hideExplicitly && message !== false || !hideExplicitly && !type.isNone(message)) {
+            close = this.context._internal.lowdefy._internal.displayMessage({
+                content: type.isString(message) ? message : defaultMessage,
+                duration,
+                status
+            });
+        }
+        return close;
+    }
+    constructor(context){
+        this.context = context;
+        this.callAction = this.callAction.bind(this);
+        this.callActionLoop = this.callActionLoop.bind(this);
+        this.callActions = this.callActions.bind(this);
+        this.displayMessage = this.displayMessage.bind(this);
+        this.actions = actions;
+    }
+};
+export default Actions;