@myinterview/widget-react 1.1.21-development-51cf6ea → 1.1.21-development-1c53386

package/dist/esm/index.js

@@ -19877,6 +19877,9 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
 function createInvokeId(stateNodeId, index) {
   return "".concat(stateNodeId, ":invocation[").concat(index, "]");
 }
+function isRaisableAction(action) {
+  return (action.type === raise$3 || action.type === send$4 && action.to === SpecialTargets.Internal) && typeof action.delay !== 'number';
+}
 
 var initEvent$1 = /*#__PURE__*/toSCXMLEvent({
   type: init$1
@@ -19953,28 +19956,40 @@ function toActivityDefinition$1(action) {
  * @param eventType The event to raise.
  */
 
-function raise$2(event) {
-  if (!isString$1(event)) {
-    return send$3(event, {
-      to: SpecialTargets.Internal
-    });
-  }
-
+function raise$2(event, options) {
   return {
     type: raise$3,
-    event: event
+    event: typeof event === 'function' ? event : toEventObject(event),
+    delay: options ? options.delay : undefined,
+    id: options === null || options === void 0 ? void 0 : options.id
   };
 }
-function resolveRaise$1(action) {
-  return {
-    type: raise$3,
-    _event: toSCXMLEvent(action.event)
+function resolveRaise$1(action, ctx, _event, delaysMap) {
+  var meta = {
+    _event: _event
   };
+  var resolvedEvent = toSCXMLEvent(isFunction$2(action.event) ? action.event(ctx, _event.data, meta) : action.event);
+  var resolvedDelay;
+
+  if (isString$1(action.delay)) {
+    var configDelay = delaysMap && delaysMap[action.delay];
+    resolvedDelay = isFunction$2(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
+  } else {
+    resolvedDelay = isFunction$2(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
+  }
+
+  return __assign$2(__assign$2({}, action), {
+    type: raise$3,
+    _event: resolvedEvent,
+    delay: resolvedDelay
+  });
 }
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
  * send the event in the next step, after the current step is finished executing.
  *
+ * @deprecated Use the `sendTo(...)` action creator instead.
+ *
  * @param event The event to send.
  * @param options Options to pass into the send event:
  *  - `id` - The unique send event identifier (used with `cancel()`).
@@ -19988,6 +20003,8 @@ function send$3(event, options) {
     type: send$4,
     event: isFunction$2(event) ? event : toEventObject(event),
     delay: options ? options.delay : undefined,
+    // TODO: don't auto-generate IDs here like that
+    // there is too big chance of the ID collision
     id: options && options.id !== undefined ? options.id : isFunction$2(event) ? event.name : getEventType(event)
   };
 }
@@ -20167,39 +20184,83 @@ function error$2(id, data) {
 
   return eventObject;
 }
-function resolveActions$1(machine, currentState, currentContext, _event, actions, predictableExec, preserveActionOrder) {
+
+var pluckAssigns$1 = function (actionBlocks) {
+  var e_1, _a;
+
+  var assignActions = [];
+
+  try {
+    for (var actionBlocks_1 = __values$1(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()) {
+      var block = actionBlocks_1_1.value;
+      var i = 0;
+
+      while (i < block.actions.length) {
+        if (block.actions[i].type === assign$4) {
+          assignActions.push(block.actions[i]);
+          block.actions.splice(i, 1);
+          continue;
+        }
+
+        i++;
+      }
+    }
+  } catch (e_1_1) {
+    e_1 = {
+      error: e_1_1
+    };
+  } finally {
+    try {
+      if (actionBlocks_1_1 && !actionBlocks_1_1.done && (_a = actionBlocks_1.return)) _a.call(actionBlocks_1);
+    } finally {
+      if (e_1) throw e_1.error;
+    }
+  }
+
+  return assignActions;
+};
+
+function resolveActions$1(machine, currentState, currentContext, _event, actionBlocks, predictableExec, preserveActionOrder) {
   if (preserveActionOrder === void 0) {
     preserveActionOrder = false;
   }
 
-  var _a = __read$3(preserveActionOrder ? [[], actions] : partition(actions, function (action) {
-    return action.type === assign$4;
-  }), 2),
-      assignActions = _a[0],
-      otherActions = _a[1];
-
+  var assignActions = preserveActionOrder ? [] : pluckAssigns$1(actionBlocks);
   var updatedContext = assignActions.length ? updateContext(currentContext, _event, assignActions, currentState) : currentContext;
   var preservedContexts = preserveActionOrder ? [currentContext] : undefined;
-  var resolvedActions = flatten(otherActions.map(function (actionObject) {
+  var deferredToBlockEnd = [];
+
+  function handleAction(blockType, actionObject) {
     var _a;
 
     switch (actionObject.type) {
       case raise$3:
         {
-          return resolveRaise$1(actionObject);
+          var raisedAction = resolveRaise$1(actionObject, updatedContext, _event, machine.options.delays);
+
+          if (predictableExec && typeof raisedAction.delay === 'number') {
+            predictableExec(raisedAction, updatedContext, _event);
+          }
+
+          return raisedAction;
         }
 
       case send$4:
         var sendAction = resolveSend$1(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
 
         if (!IS_PRODUCTION$1) {
-          // warn after resolving as we can create better contextual message here
-          warn$1(!isString$1(actionObject.delay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
-          "No delay reference for delay expression '".concat(actionObject.delay, "' was found on machine '").concat(machine.id, "'"));
+          var configuredDelay = actionObject.delay; // warn after resolving as we can create better contextual message here
+
+          warn$1(!isString$1(configuredDelay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
+          "No delay reference for delay expression '".concat(configuredDelay, "' was found on machine '").concat(machine.id, "'"));
         }
 
-        if (sendAction.to !== SpecialTargets.Internal) {
-          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(sendAction, updatedContext, _event);
+        if (predictableExec && sendAction.to !== SpecialTargets.Internal) {
+          if (blockType === 'entry') {
+            deferredToBlockEnd.push(sendAction);
+          } else {
+            predictableExec(sendAction, updatedContext, _event);
+          }
         }
 
         return sendAction;
@@ -20223,7 +20284,10 @@ function resolveActions$1(machine, currentState, currentContext, _event, actions
             return [];
           }
 
-          var _b = __read$3(resolveActions$1(machine, currentState, updatedContext, _event, toActionObjects$1(toArray$1(matchedActions), machine.options.actions), predictableExec, preserveActionOrder), 2),
+          var _b = __read$3(resolveActions$1(machine, currentState, updatedContext, _event, [{
+            type: blockType,
+            actions: toActionObjects$1(toArray$1(matchedActions), machine.options.actions)
+          }], predictableExec, preserveActionOrder), 2),
               resolvedActionsFromChoose = _b[0],
               resolvedContextFromChoose = _b[1];
 
@@ -20240,7 +20304,10 @@ function resolveActions$1(machine, currentState, currentContext, _event, actions
             return [];
           }
 
-          var _c = __read$3(resolveActions$1(machine, currentState, updatedContext, _event, toActionObjects$1(toArray$1(matchedActions), machine.options.actions), predictableExec, preserveActionOrder), 2),
+          var _c = __read$3(resolveActions$1(machine, currentState, updatedContext, _event, [{
+            type: blockType,
+            actions: toActionObjects$1(toArray$1(matchedActions), machine.options.actions)
+          }], predictableExec, preserveActionOrder), 2),
               resolvedActionsFromPure = _c[0],
               resolvedContext = _c[1];
 
@@ -20252,7 +20319,7 @@ function resolveActions$1(machine, currentState, currentContext, _event, actions
       case stop$3:
         {
           var resolved = resolveStop$1(actionObject, updatedContext, _event);
-          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, updatedContext, _event);
+          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, currentContext, _event);
           return resolved;
         }
 
@@ -20271,7 +20338,8 @@ function resolveActions$1(machine, currentState, currentContext, _event, actions
           predictableExec(resolvedActionObject, updatedContext, _event);
         } else if (exec_1 && preservedContexts) {
           var contextIndex_1 = preservedContexts.length - 1;
-          resolvedActionObject = __assign$2(__assign$2({}, resolvedActionObject), {
+
+          var wrapped = __assign$2(__assign$2({}, resolvedActionObject), {
             exec: function (_ctx) {
               var args = [];
 
@@ -20282,13 +20350,48 @@ function resolveActions$1(machine, currentState, currentContext, _event, actions
               exec_1.apply(void 0, __spreadArray$1([preservedContexts[contextIndex_1]], __read$3(args), false));
             }
           });
+
+          resolvedActionObject = wrapped;
         }
 
         return resolvedActionObject;
     }
-  }).filter(function (a) {
-    return !!a;
-  }));
+  }
+
+  function processBlock(block) {
+    var e_2, _a;
+
+    var resolvedActions = [];
+
+    try {
+      for (var _b = __values$1(block.actions), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var action = _c.value;
+        var resolved = handleAction(block.type, action);
+
+        if (resolved) {
+          resolvedActions = resolvedActions.concat(resolved);
+        }
+      }
+    } catch (e_2_1) {
+      e_2 = {
+        error: e_2_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_2) throw e_2.error;
+      }
+    }
+
+    deferredToBlockEnd.forEach(function (action) {
+      predictableExec(action, updatedContext, _event);
+    });
+    deferredToBlockEnd.length = 0;
+    return resolvedActions;
+  }
+
+  var resolvedActions = flatten(actionBlocks.map(processBlock));
   return [resolvedActions, updatedContext];
 }
 
@@ -21140,12 +21243,12 @@ function () {
    * @param options Interpreter options
    */
   function Interpreter(machine, options) {
-    var _this = this;
-
     if (options === void 0) {
       options = Interpreter.defaultOptions;
     }
 
+    var _this = this;
+
     this.machine = machine;
     this.delayedEventsMap = {};
     this.listeners = new Set();
@@ -21162,6 +21265,7 @@ function () {
     this.status = InterpreterStatus.NotStarted;
     this.children = new Map();
     this.forwardTo = new Set();
+    this._outgoingQueue = [];
     /**
      * Alias for Interpreter.prototype.start
      */
@@ -21213,9 +21317,9 @@ function () {
       // tslint:disable-next-line:semicolon
     };
 
-    this.sendTo = function (event, to) {
+    this.sendTo = function (event, to, immediate) {
       var isParent = _this.parent && (to === SpecialTargets.Parent || _this.parent.id === to);
-      var target = isParent ? _this.parent : isString$1(to) ? _this.children.get(to) || registry.get(to) : isActor$1(to) ? to : undefined;
+      var target = isParent ? _this.parent : isString$1(to) ? to === SpecialTargets.Internal ? _this : _this.children.get(to) || registry.get(to) : isActor$1(to) ? to : undefined;
 
       if (!target) {
         if (!isParent) {
@@ -21236,14 +21340,24 @@ function () {
         if (_this.status !== InterpreterStatus.Stopped || _this.parent !== target || // we need to send events to the parent from exit handlers of a machine that reached its final state
         _this.state.done) {
           // Send SCXML events to machines
-          target.send(__assign$2(__assign$2({}, event), {
+          var scxmlEvent = __assign$2(__assign$2({}, event), {
             name: event.name === error$3 ? "".concat(error$2(_this.id)) : event.name,
             origin: _this.sessionId
-          }));
+          });
+
+          if (!immediate && _this.machine.config.predictableActionArguments) {
+            _this._outgoingQueue.push([target, scxmlEvent]);
+          } else {
+            target.send(scxmlEvent);
+          }
         }
       } else {
         // Send normal events to other targets
-        target.send(event.data);
+        if (!immediate && _this.machine.config.predictableActionArguments) {
+          _this._outgoingQueue.push([target, event.data]);
+        } else {
+          target.send(event.data);
+        }
       }
     };
 
@@ -21278,6 +21392,16 @@ function () {
       }
 
       switch (action.type) {
+        case raise$3:
+          {
+            // if raise action reached the interpreter then it's a delayed one
+            var sendAction_1 = action;
+
+            _this.defer(sendAction_1);
+
+            break;
+          }
+
         case send$4:
           var sendAction = action;
 
@@ -21287,7 +21411,7 @@ function () {
             return;
           } else {
             if (sendAction.to) {
-              _this.sendTo(sendAction._event, sendAction.to);
+              _this.sendTo(sendAction._event, sendAction.to, _event === initEvent$1);
             } else {
               _this.send(sendAction._event);
             }
@@ -21381,8 +21505,9 @@ function () {
           }
 
         case log$2:
-          var label = action.label,
-              value = action.value;
+          var _a = action,
+              label = _a.label,
+              value = _a.value;
 
           if (label) {
             _this.logger(label, value);
@@ -21436,6 +21561,9 @@ function () {
     configurable: true
   });
   Object.defineProperty(Interpreter.prototype, "state", {
+    /**
+     * @deprecated Use `.getSnapshot()` instead.
+     */
     get: function () {
       if (!IS_PRODUCTION$1) {
         warn$1(this.status !== InterpreterStatus.NotStarted, "Attempted to read state from uninitialized service '".concat(this.id, "'. Make sure the service is started first."));
@@ -21488,6 +21616,12 @@ function () {
     // we can't just recompute it (and execute actions while doing so) because we try to preserve identity of actors created within initial assigns
     _event === initEvent$1) && this.options.execute) {
       this.execute(this.state);
+    } else {
+      var item = void 0;
+
+      while (item = this._outgoingQueue.shift()) {
+        item[0].send(item[1]);
+      }
     } // Update children
 
 
@@ -21559,11 +21693,12 @@ function () {
         return sn.type === 'final' && sn.parent === _this.machine;
       });
       var doneData = finalChildStateNode && finalChildStateNode.doneData ? mapContext(finalChildStateNode.doneData, state.context, _event) : undefined;
+      this._doneEvent = doneInvoke$1(this.id, doneData);
 
       try {
         for (var _l = __values$1(this.doneListeners), _m = _l.next(); !_m.done; _m = _l.next()) {
           var listener = _m.value;
-          listener(doneInvoke$1(this.id, doneData));
+          listener(this._doneEvent);
         }
       } catch (e_5_1) {
         e_5 = {
@@ -21580,6 +21715,8 @@ function () {
       this._stop();
 
       this._stopChildren();
+
+      registry.free(this.sessionId);
     }
   };
   /*
@@ -21683,7 +21820,12 @@ function () {
 
 
   Interpreter.prototype.onDone = function (listener) {
-    this.doneListeners.add(listener);
+    if (this.status === InterpreterStatus.Stopped && this._doneEvent) {
+      listener(this._doneEvent);
+    } else {
+      this.doneListeners.add(listener);
+    }
+
     return this;
   };
   /**
@@ -21885,7 +22027,10 @@ function () {
           return toActionObjects$1(stateNode.onExit, _this.machine.options.actions);
         }));
 
-        var _a = __read$3(resolveActions$1(_this.machine, _this.state, _this.state.context, _event, exitActions, _this.machine.config.predictableActionArguments ? _this._exec : undefined, _this.machine.config.predictableActionArguments || _this.machine.config.preserveActionOrder), 2),
+        var _a = __read$3(resolveActions$1(_this.machine, _this.state, _this.state.context, _event, [{
+          type: 'exit',
+          actions: exitActions
+        }], _this.machine.config.predictableActionArguments ? _this._exec : undefined, _this.machine.config.predictableActionArguments || _this.machine.config.preserveActionOrder), 2),
             resolvedActions = _a[0],
             updatedContext = _a[1];
 
@@ -21897,7 +22042,7 @@ function () {
           historyValue: undefined,
           history: _this.state,
           actions: resolvedActions.filter(function (action) {
-            return action.type !== raise$3 && (action.type !== send$4 || !!action.to && action.to !== SpecialTargets.Internal);
+            return !isRaisableAction(action);
           }),
           activities: {},
           events: [],
@@ -21934,6 +22079,11 @@ function () {
       "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options."));
     }
 
+    if (!events.length) {
+      return;
+    }
+
+    var exec = !!this.machine.config.predictableActionArguments && this._exec;
     this.scheduler.schedule(function () {
       var e_11, _a;
 
@@ -21947,9 +22097,9 @@ function () {
         _this.forward(_event);
 
         nextState = provide(_this, function () {
-          return _this.machine.transition(nextState, _event);
+          return _this.machine.transition(nextState, _event, undefined, exec || undefined);
         });
-        batchedActions.push.apply(batchedActions, __spreadArray$1([], __read$3(nextState.actions.map(function (a) {
+        batchedActions.push.apply(batchedActions, __spreadArray$1([], __read$3(_this.machine.config.predictableActionArguments ? nextState.actions : nextState.actions.map(function (a) {
           return bindActionToState(a, nextState);
         })), false));
         batchChanged = batchChanged || !!nextState.changed;
@@ -22053,13 +22203,17 @@ function () {
   Interpreter.prototype.defer = function (sendAction) {
     var _this = this;
 
-    this.delayedEventsMap[sendAction.id] = this.clock.setTimeout(function () {
-      if (sendAction.to) {
-        _this.sendTo(sendAction._event, sendAction.to);
+    var timerId = this.clock.setTimeout(function () {
+      if ('to' in sendAction && sendAction.to) {
+        _this.sendTo(sendAction._event, sendAction.to, true);
       } else {
         _this.send(sendAction._event);
       }
     }, sendAction.delay);
+
+    if (sendAction.id) {
+      this.delayedEventsMap[sendAction.id] = timerId;
+    }
   };
 
   Interpreter.prototype.cancel = function (sendId) {
@@ -22636,12 +22790,12 @@ function () {
    */
   _context, // TODO: this is unsafe, but we're removing it in v5 anyway
   _stateInfo) {
-    var _this = this;
-
     if (_context === void 0) {
       _context = 'context' in config ? config.context : undefined;
     }
 
+    var _this = this;
+
     var _a;
 
     this.config = config;
@@ -23104,15 +23258,11 @@ function () {
       return this.next(state, _event);
     }
 
-    var entryNodes = flatten(stateTransitions.map(function (t) {
-      return t.entrySet;
-    }));
     var configuration = flatten(Object.keys(transitionMap).map(function (key) {
       return transitionMap[key].configuration;
     }));
     return {
       transitions: enabledTransitions,
-      entrySet: entryNodes,
       exitSet: flatten(stateTransitions.map(function (t) {
         return t.exitSet;
       })),
@@ -23199,7 +23349,6 @@ function () {
     if (!nextStateNodes.length) {
       return {
         transitions: [selectedTransition],
-        entrySet: [],
         exitSet: [],
         configuration: state.value ? [this] : [],
         source: state,
@@ -23211,30 +23360,28 @@ function () {
       return _this.getRelativeStateNodes(stateNode, state.historyValue);
     }));
     var isInternal = !!selectedTransition.internal;
-    var reentryNodes = [];
-
-    if (!isInternal) {
-      nextStateNodes.forEach(function (targetNode) {
-        reentryNodes.push.apply(reentryNodes, __spreadArray$1([], __read$3(_this.getExternalReentryNodes(targetNode)), false));
-      });
-    }
-
     return {
       transitions: [selectedTransition],
-      entrySet: reentryNodes,
-      exitSet: isInternal ? [] : [this],
+      exitSet: isInternal ? [] : flatten(nextStateNodes.map(function (targetNode) {
+        return _this.getPotentiallyReenteringNodes(targetNode);
+      })),
       configuration: allNextStateNodes,
       source: state,
       actions: actions
     };
-  };
+  }; // even though the name of this function mentions reentry nodes
+  // we are pushing its result into `exitSet`
+  // that's because what we exit might be reentered (it's an invariant of reentrancy)
 
-  StateNode.prototype.getExternalReentryNodes = function (targetNode) {
-    var nodes = [];
 
-    var _a = __read$3(targetNode.order > this.order ? [targetNode, this] : [this, targetNode], 2),
-        marker = _a[0],
-        possibleAncestor = _a[1];
+  StateNode.prototype.getPotentiallyReenteringNodes = function (targetNode) {
+    if (this.order < targetNode.order) {
+      return [this];
+    }
+
+    var nodes = [];
+    var marker = this;
+    var possibleAncestor = targetNode;
 
     while (marker && marker !== possibleAncestor) {
       nodes.push(marker);
@@ -23251,17 +23398,22 @@ function () {
     return nodes;
   };
 
-  StateNode.prototype.getActions = function (resolvedConfig, isDone, transition, currentContext, _event, prevState) {
+  StateNode.prototype.getActions = function (resolvedConfig, isDone, transition, currentContext, _event, prevState, predictableExec) {
     var e_4, _a, e_5, _b;
 
-    var prevConfig = getConfiguration([], prevState ? this.getStateNodes(prevState.value) : [this]);
+    var _this = this;
+
+    var prevConfig = prevState ? getConfiguration([], this.getStateNodes(prevState.value)) : [];
+    var entrySet = new Set();
 
     try {
-      for (var resolvedConfig_1 = __values$1(resolvedConfig), resolvedConfig_1_1 = resolvedConfig_1.next(); !resolvedConfig_1_1.done; resolvedConfig_1_1 = resolvedConfig_1.next()) {
-        var sn = resolvedConfig_1_1.value;
+      for (var _c = __values$1(Array.from(resolvedConfig).sort(function (a, b) {
+        return a.order - b.order;
+      })), _d = _c.next(); !_d.done; _d = _c.next()) {
+        var sn = _d.value;
 
-        if (!has(prevConfig, sn) || has(transition.entrySet, sn.parent)) {
-          transition.entrySet.push(sn);
+        if (!has(prevConfig, sn) || has(transition.exitSet, sn) || sn.parent && entrySet.has(sn.parent)) {
+          entrySet.add(sn);
         }
       }
     } catch (e_4_1) {
@@ -23270,7 +23422,7 @@ function () {
       };
     } finally {
       try {
-        if (resolvedConfig_1_1 && !resolvedConfig_1_1.done && (_a = resolvedConfig_1.return)) _a.call(resolvedConfig_1);
+        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
       } finally {
         if (e_4) throw e_4.error;
       }
@@ -23296,7 +23448,14 @@ function () {
       }
     }
 
-    var doneEvents = flatten(transition.entrySet.map(function (sn) {
+    transition.exitSet.sort(function (a, b) {
+      return b.order - a.order;
+    });
+    var entryStates = Array.from(entrySet).sort(function (a, b) {
+      return a.order - b.order;
+    });
+    var exitStates = new Set(transition.exitSet);
+    var doneEvents = flatten(entryStates.map(function (sn) {
       var events = [];
 
       if (sn.type !== 'final') {
@@ -23323,28 +23482,33 @@ function () {
 
       return events;
     }));
-    transition.exitSet.sort(function (a, b) {
-      return b.order - a.order;
+    var entryActions = entryStates.map(function (stateNode) {
+      var entryActions = stateNode.onEntry;
+      var invokeActions = stateNode.activities.map(function (activity) {
+        return start$2(activity);
+      });
+      return {
+        type: 'entry',
+        actions: toActionObjects$1(predictableExec ? __spreadArray$1(__spreadArray$1([], __read$3(entryActions), false), __read$3(invokeActions), false) : __spreadArray$1(__spreadArray$1([], __read$3(invokeActions), false), __read$3(entryActions), false), _this.machine.options.actions)
+      };
+    }).concat({
+      type: 'state_done',
+      actions: doneEvents.map(function (event) {
+        return raise$2(event);
+      })
     });
-    transition.entrySet.sort(function (a, b) {
-      return a.order - b.order;
+    var exitActions = Array.from(exitStates).map(function (stateNode) {
+      return {
+        type: 'exit',
+        actions: toActionObjects$1(__spreadArray$1(__spreadArray$1([], __read$3(stateNode.onExit), false), __read$3(stateNode.activities.map(function (activity) {
+          return stop$2(activity);
+        })), false), _this.machine.options.actions)
+      };
     });
-    var entryStates = new Set(transition.entrySet);
-    var exitStates = new Set(transition.exitSet);
-
-    var _c = __read$3([flatten(Array.from(entryStates).map(function (stateNode) {
-      return __spreadArray$1(__spreadArray$1([], __read$3(stateNode.activities.map(function (activity) {
-        return start$2(activity);
-      })), false), __read$3(stateNode.onEntry), false);
-    })).concat(doneEvents.map(raise$2)), flatten(Array.from(exitStates).map(function (stateNode) {
-      return __spreadArray$1(__spreadArray$1([], __read$3(stateNode.onExit), false), __read$3(stateNode.activities.map(function (activity) {
-        return stop$2(activity);
-      })), false);
-    }))], 2),
-        entryActions = _c[0],
-        exitActions = _c[1];
-
-    var actions = toActionObjects$1(exitActions.concat(transition.actions).concat(entryActions), this.machine.options.actions);
+    var actions = exitActions.concat({
+      type: 'transition',
+      actions: toActionObjects$1(transition.actions, this.machine.options.actions)
+    }).concat(entryActions);
 
     if (isDone) {
       var stopActions = toActionObjects$1(flatten(__spreadArray$1([], __read$3(resolvedConfig), false).sort(function (a, b) {
@@ -23352,9 +23516,12 @@ function () {
       }).map(function (stateNode) {
         return stateNode.onExit;
       })), this.machine.options.actions).filter(function (action) {
-        return action.type !== raise$3 && (action.type !== send$4 || !!action.to && action.to !== SpecialTargets.Internal);
+        return !isRaisableAction(action);
+      });
+      return actions.concat({
+        type: 'stop',
+        actions: stopActions
       });
-      return actions.concat(stopActions);
     }
 
     return actions;
@@ -23398,7 +23565,6 @@ function () {
     var stateTransition = this._transition(currentState.value, currentState, _event) || {
       transitions: [],
       configuration: [],
-      entrySet: [],
       exitSet: [],
       source: currentState,
       actions: []
@@ -23425,7 +23591,7 @@ function () {
   };
 
   StateNode.prototype.resolveTransition = function (stateTransition, currentState, context, predictableExec, _event) {
-    var e_6, _a;
+    var e_6, _a, e_7, _b;
 
     var _this = this;
 
@@ -23442,17 +23608,33 @@ function () {
     var isDone = isInFinalState(resolvedConfiguration, this);
     var resolvedStateValue = willTransition ? getValue(this.machine, configuration) : undefined;
     var historyValue = currentState ? currentState.historyValue ? currentState.historyValue : stateTransition.source ? this.machine.historyValue(currentState.value) : undefined : undefined;
-    var actions = this.getActions(new Set(resolvedConfiguration), isDone, stateTransition, context, _event, currentState);
+    var actionBlocks = this.getActions(new Set(resolvedConfiguration), isDone, stateTransition, context, _event, currentState, predictableExec);
     var activities = currentState ? __assign$2({}, currentState.activities) : {};
 
     try {
-      for (var actions_1 = __values$1(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
-        var action = actions_1_1.value;
+      for (var actionBlocks_1 = __values$1(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()) {
+        var block = actionBlocks_1_1.value;
 
-        if (action.type === start$3) {
-          activities[action.activity.id || action.activity.type] = action;
-        } else if (action.type === stop$3) {
-          activities[action.activity.id || action.activity.type] = false;
+        try {
+          for (var _c = (e_7 = void 0, __values$1(block.actions)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var action = _d.value;
+
+            if (action.type === start$3) {
+              activities[action.activity.id || action.activity.type] = action;
+            } else if (action.type === stop$3) {
+              activities[action.activity.id || action.activity.type] = false;
+            }
+          }
+        } catch (e_7_1) {
+          e_7 = {
+            error: e_7_1
+          };
+        } finally {
+          try {
+            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+          } finally {
+            if (e_7) throw e_7.error;
+          }
         }
       }
     } catch (e_6_1) {
@@ -23461,21 +23643,19 @@ function () {
       };
     } finally {
       try {
-        if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
+        if (actionBlocks_1_1 && !actionBlocks_1_1.done && (_a = actionBlocks_1.return)) _a.call(actionBlocks_1);
       } finally {
         if (e_6) throw e_6.error;
       }
     }
 
-    var _b = __read$3(resolveActions$1(this, currentState, context, _event, actions, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2),
-        resolvedActions = _b[0],
-        updatedContext = _b[1];
+    var _e = __read$3(resolveActions$1(this, currentState, context, _event, actionBlocks, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2),
+        resolvedActions = _e[0],
+        updatedContext = _e[1];
 
-    var _c = __read$3(partition(resolvedActions, function (action) {
-      return action.type === raise$3 || action.type === send$4 && action.to === SpecialTargets.Internal;
-    }), 2),
-        raisedEvents = _c[0],
-        nonRaisedActions = _c[1];
+    var _f = __read$3(partition(resolvedActions, isRaisableAction), 2),
+        raisedEvents = _f[0],
+        nonRaisedActions = _f[1];
 
     var invokeActions = resolvedActions.filter(function (action) {
       var _a;
@@ -23728,7 +23908,6 @@ function () {
     var configuration = this.getStateNodes(stateValue);
     return this.resolveTransition({
       configuration: configuration,
-      entrySet: __spreadArray$1([], __read$3(configuration), false),
       exitSet: [],
       transitions: [],
       source: undefined,
@@ -23924,7 +24103,7 @@ function () {
      * All the event types accepted by this state node and its descendants.
      */
     get: function () {
-      var e_7, _a, e_8, _b;
+      var e_8, _a, e_9, _b;
 
       if (this.__cache.events) {
         return this.__cache.events;
@@ -23941,32 +24120,32 @@ function () {
 
             if (state.states) {
               try {
-                for (var _e = (e_8 = void 0, __values$1(state.events)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = (e_9 = void 0, __values$1(state.events)), _f = _e.next(); !_f.done; _f = _e.next()) {
                   var event_1 = _f.value;
                   events.add("".concat(event_1));
                 }
-              } catch (e_8_1) {
-                e_8 = {
-                  error: e_8_1
+              } catch (e_9_1) {
+                e_9 = {
+                  error: e_9_1
                 };
               } finally {
                 try {
                   if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 } finally {
-                  if (e_8) throw e_8.error;
+                  if (e_9) throw e_9.error;
                 }
               }
             }
           }
-        } catch (e_7_1) {
-          e_7 = {
-            error: e_7_1
+        } catch (e_8_1) {
+          e_8 = {
+            error: e_8_1
           };
         } finally {
           try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
           } finally {
-            if (e_7) throw e_7.error;
+            if (e_8) throw e_8.error;
           }
         }
       }
@@ -24061,7 +24240,7 @@ function () {
   };
 
   StateNode.prototype.formatTransitions = function () {
-    var e_9, _a;
+    var e_10, _a;
 
     var _this = this;
 
@@ -24125,15 +24304,15 @@ function () {
         var delayedTransition = delayedTransitions_1_1.value;
         formattedTransitions.push(delayedTransition);
       }
-    } catch (e_9_1) {
-      e_9 = {
-        error: e_9_1
+    } catch (e_10_1) {
+      e_10 = {
+        error: e_10_1
       };
     } finally {
       try {
         if (delayedTransitions_1_1 && !delayedTransitions_1_1.done && (_a = delayedTransitions_1.return)) _a.call(delayedTransitions_1);
       } finally {
-        if (e_9) throw e_9.error;
+        if (e_10) throw e_10.error;
       }
     }
 
@@ -24145,7 +24324,7 @@ function () {
 
 var warned = false;
 function createMachine(config, options) {
-  if (!IS_PRODUCTION$1 && !config.predictableActionArguments && !warned) {
+  if (!IS_PRODUCTION$1 && !('predictableActionArguments' in config) && !warned) {
     warned = true;
     console.warn('It is highly recommended to set `predictableActionArguments` to `true` when using `createMachine`. https://xstate.js.org/docs/guides/actions.html');
   }
@@ -38920,6 +39099,8 @@ environment$1.IS_PRODUCTION = IS_PRODUCTION;
 	Object.defineProperty(exports, '__esModule', { value: true });
 
 	var _tslib = _tslib$1;
+	var types = types$2;
+	var actionTypes = actionTypes$1;
 	var constants$1 = constants;
 	var environment = environment$1;
 
@@ -39539,6 +39720,9 @@ environment$1.IS_PRODUCTION = IS_PRODUCTION;
 	function createInvokeId(stateNodeId, index) {
 	  return "".concat(stateNodeId, ":invocation[").concat(index, "]");
 	}
+	function isRaisableAction(action) {
+	  return (action.type === actionTypes.raise || action.type === actionTypes.send && action.to === types.SpecialTargets.Internal) && typeof action.delay !== 'number';
+	}
 
 	exports.createInvokeId = createInvokeId;
 	exports.evaluateGuard = evaluateGuard;
@@ -39554,6 +39738,7 @@ environment$1.IS_PRODUCTION = IS_PRODUCTION;
 	exports.isMachine = isMachine;
 	exports.isObservable = isObservable;
 	exports.isPromiseLike = isPromiseLike;
+	exports.isRaisableAction = isRaisableAction;
 	exports.isStateLike = isStateLike;
 	exports.isString = isString;
 	exports.keys = keys;
@@ -39669,28 +39854,40 @@ function toActivityDefinition(action) {
  * @param eventType The event to raise.
  */
 
-function raise(event) {
-  if (!utils.isString(event)) {
-    return send(event, {
-      to: types.SpecialTargets.Internal
-    });
-  }
-
+function raise(event, options) {
   return {
     type: actionTypes.raise,
-    event: event
+    event: typeof event === 'function' ? event : utils.toEventObject(event),
+    delay: options ? options.delay : undefined,
+    id: options === null || options === void 0 ? void 0 : options.id
   };
 }
-function resolveRaise(action) {
-  return {
-    type: actionTypes.raise,
-    _event: utils.toSCXMLEvent(action.event)
+function resolveRaise(action, ctx, _event, delaysMap) {
+  var meta = {
+    _event: _event
   };
+  var resolvedEvent = utils.toSCXMLEvent(utils.isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
+  var resolvedDelay;
+
+  if (utils.isString(action.delay)) {
+    var configDelay = delaysMap && delaysMap[action.delay];
+    resolvedDelay = utils.isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
+  } else {
+    resolvedDelay = utils.isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
+  }
+
+  return _tslib.__assign(_tslib.__assign({}, action), {
+    type: actionTypes.raise,
+    _event: resolvedEvent,
+    delay: resolvedDelay
+  });
 }
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
  * send the event in the next step, after the current step is finished executing.
  *
+ * @deprecated Use the `sendTo(...)` action creator instead.
+ *
  * @param event The event to send.
  * @param options Options to pass into the send event:
  *  - `id` - The unique send event identifier (used with `cancel()`).
@@ -39704,6 +39901,8 @@ function send(event, options) {
     type: actionTypes.send,
     event: utils.isFunction(event) ? event : utils.toEventObject(event),
     delay: options ? options.delay : undefined,
+    // TODO: don't auto-generate IDs here like that
+    // there is too big chance of the ID collision
     id: options && options.id !== undefined ? options.id : utils.isFunction(event) ? event.name : utils.getEventType(event)
   };
 }
@@ -40014,39 +40213,83 @@ function choose(conds) {
     conds: conds
   };
 }
-function resolveActions(machine, currentState, currentContext, _event, actions, predictableExec, preserveActionOrder) {
+
+var pluckAssigns = function (actionBlocks) {
+  var e_1, _a;
+
+  var assignActions = [];
+
+  try {
+    for (var actionBlocks_1 = _tslib.__values(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()) {
+      var block = actionBlocks_1_1.value;
+      var i = 0;
+
+      while (i < block.actions.length) {
+        if (block.actions[i].type === actionTypes.assign) {
+          assignActions.push(block.actions[i]);
+          block.actions.splice(i, 1);
+          continue;
+        }
+
+        i++;
+      }
+    }
+  } catch (e_1_1) {
+    e_1 = {
+      error: e_1_1
+    };
+  } finally {
+    try {
+      if (actionBlocks_1_1 && !actionBlocks_1_1.done && (_a = actionBlocks_1.return)) _a.call(actionBlocks_1);
+    } finally {
+      if (e_1) throw e_1.error;
+    }
+  }
+
+  return assignActions;
+};
+
+function resolveActions(machine, currentState, currentContext, _event, actionBlocks, predictableExec, preserveActionOrder) {
   if (preserveActionOrder === void 0) {
     preserveActionOrder = false;
   }
 
-  var _a = _tslib.__read(preserveActionOrder ? [[], actions] : utils.partition(actions, function (action) {
-    return action.type === actionTypes.assign;
-  }), 2),
-      assignActions = _a[0],
-      otherActions = _a[1];
-
+  var assignActions = preserveActionOrder ? [] : pluckAssigns(actionBlocks);
   var updatedContext = assignActions.length ? utils.updateContext(currentContext, _event, assignActions, currentState) : currentContext;
   var preservedContexts = preserveActionOrder ? [currentContext] : undefined;
-  var resolvedActions = utils.flatten(otherActions.map(function (actionObject) {
+  var deferredToBlockEnd = [];
+
+  function handleAction(blockType, actionObject) {
     var _a;
 
     switch (actionObject.type) {
       case actionTypes.raise:
         {
-          return resolveRaise(actionObject);
+          var raisedAction = resolveRaise(actionObject, updatedContext, _event, machine.options.delays);
+
+          if (predictableExec && typeof raisedAction.delay === 'number') {
+            predictableExec(raisedAction, updatedContext, _event);
+          }
+
+          return raisedAction;
         }
 
       case actionTypes.send:
         var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
 
         if (!environment.IS_PRODUCTION) {
-          // warn after resolving as we can create better contextual message here
-          utils.warn(!utils.isString(actionObject.delay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
-          "No delay reference for delay expression '".concat(actionObject.delay, "' was found on machine '").concat(machine.id, "'"));
+          var configuredDelay = actionObject.delay; // warn after resolving as we can create better contextual message here
+
+          utils.warn(!utils.isString(configuredDelay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
+          "No delay reference for delay expression '".concat(configuredDelay, "' was found on machine '").concat(machine.id, "'"));
         }
 
-        if (sendAction.to !== types.SpecialTargets.Internal) {
-          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(sendAction, updatedContext, _event);
+        if (predictableExec && sendAction.to !== types.SpecialTargets.Internal) {
+          if (blockType === 'entry') {
+            deferredToBlockEnd.push(sendAction);
+          } else {
+            predictableExec(sendAction, updatedContext, _event);
+          }
         }
 
         return sendAction;
@@ -40070,7 +40313,10 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
             return [];
           }
 
-          var _b = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(utils.toArray(matchedActions), machine.options.actions), predictableExec, preserveActionOrder), 2),
+          var _b = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, [{
+            type: blockType,
+            actions: toActionObjects(utils.toArray(matchedActions), machine.options.actions)
+          }], predictableExec, preserveActionOrder), 2),
               resolvedActionsFromChoose = _b[0],
               resolvedContextFromChoose = _b[1];
 
@@ -40087,7 +40333,10 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
             return [];
           }
 
-          var _c = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(utils.toArray(matchedActions), machine.options.actions), predictableExec, preserveActionOrder), 2),
+          var _c = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, [{
+            type: blockType,
+            actions: toActionObjects(utils.toArray(matchedActions), machine.options.actions)
+          }], predictableExec, preserveActionOrder), 2),
               resolvedActionsFromPure = _c[0],
               resolvedContext = _c[1];
 
@@ -40099,7 +40348,7 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
       case actionTypes.stop:
         {
           var resolved = resolveStop(actionObject, updatedContext, _event);
-          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, updatedContext, _event);
+          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, currentContext, _event);
           return resolved;
         }
 
@@ -40118,7 +40367,8 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
           predictableExec(resolvedActionObject, updatedContext, _event);
         } else if (exec_1 && preservedContexts) {
           var contextIndex_1 = preservedContexts.length - 1;
-          resolvedActionObject = _tslib.__assign(_tslib.__assign({}, resolvedActionObject), {
+
+          var wrapped = _tslib.__assign(_tslib.__assign({}, resolvedActionObject), {
             exec: function (_ctx) {
               var args = [];
 
@@ -40129,13 +40379,48 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
               exec_1.apply(void 0, _tslib.__spreadArray([preservedContexts[contextIndex_1]], _tslib.__read(args), false));
             }
           });
+
+          resolvedActionObject = wrapped;
         }
 
         return resolvedActionObject;
     }
-  }).filter(function (a) {
-    return !!a;
-  }));
+  }
+
+  function processBlock(block) {
+    var e_2, _a;
+
+    var resolvedActions = [];
+
+    try {
+      for (var _b = _tslib.__values(block.actions), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var action = _c.value;
+        var resolved = handleAction(block.type, action);
+
+        if (resolved) {
+          resolvedActions = resolvedActions.concat(resolved);
+        }
+      }
+    } catch (e_2_1) {
+      e_2 = {
+        error: e_2_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_2) throw e_2.error;
+      }
+    }
+
+    deferredToBlockEnd.forEach(function (action) {
+      predictableExec(action, updatedContext, _event);
+    });
+    deferredToBlockEnd.length = 0;
+    return resolvedActions;
+  }
+
+  var resolvedActions = utils.flatten(actionBlocks.map(processBlock));
   return [resolvedActions, updatedContext];
 }