@storybook/instrumenter 6.4.0-alpha.35

package/dist/cjs/instrumenter.js

@@ -0,0 +1,725 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.symbol.description.js");
+
+require("core-js/modules/es.symbol.iterator.js");
+
+require("core-js/modules/es.symbol.to-primitive.js");
+
+require("core-js/modules/es.date.to-primitive.js");
+
+require("core-js/modules/es.number.constructor.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instrument = exports.Instrumenter = exports.EVENTS = void 0;
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.map.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.set.js");
+
+require("core-js/modules/es.array.filter.js");
+
+require("core-js/modules/es.array.from.js");
+
+require("core-js/modules/es.object.assign.js");
+
+require("core-js/modules/es.array.map.js");
+
+require("core-js/modules/es.array.find-index.js");
+
+require("core-js/modules/es.array.slice.js");
+
+require("core-js/modules/es.array.find.js");
+
+require("core-js/modules/web.dom-collections.for-each.js");
+
+require("core-js/modules/es.object.values.js");
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.array.concat.js");
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/es.function.name.js");
+
+require("core-js/modules/es.array.includes.js");
+
+var _addons = require("@storybook/addons");
+
+var _coreEvents = require("@storybook/core-events");
+
+var _global = _interopRequireDefault(require("global"));
+
+var _types = require("./types");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var EVENTS = {
+  CALL: 'instrumenter/call',
+  SYNC: 'instrumenter/sync',
+  START: 'instrumenter/start',
+  BACK: 'instrumenter/back',
+  GOTO: 'instrumenter/goto',
+  NEXT: 'instrumenter/next',
+  END: 'instrumenter/end'
+};
+exports.EVENTS = EVENTS;
+
+var isObject = function isObject(o) {
+  return Object.prototype.toString.call(o) === '[object Object]';
+};
+
+var isModule = function isModule(o) {
+  return Object.prototype.toString.call(o) === '[object Module]';
+};
+
+var isInstrumentable = function isInstrumentable(o) {
+  if (!isObject(o) && !isModule(o)) return false;
+  if (o.constructor === undefined) return true;
+  var proto = o.constructor.prototype;
+  if (!isObject(proto)) return false;
+  if (Object.prototype.hasOwnProperty.call(proto, 'isPrototypeOf') === false) return false;
+  return true;
+};
+
+var construct = function construct(obj) {
+  try {
+    return new obj.constructor();
+  } catch (e) {
+    return {};
+  }
+};
+
+var getInitialState = function getInitialState() {
+  return {
+    isDebugging: false,
+    cursor: 0,
+    calls: [],
+    shadowCalls: [],
+    callRefsByResult: new Map(),
+    chainedCallIds: new Set(),
+    parentCallId: undefined,
+    playUntil: undefined,
+    resolvers: {},
+    syncTimeout: undefined,
+    forwardedException: undefined
+  };
+};
+
+var Instrumenter = /*#__PURE__*/function () {
+  function Instrumenter() {
+    var _this = this;
+
+    _classCallCheck(this, Instrumenter);
+
+    this.channel = void 0;
+    this.state = void 0;
+    this.channel = _addons.addons.getChannel();
+    this.state = // Restore state from the parent window in case the iframe was reloaded.
+    _global.default.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ || getInitialState(); // When called from `start`, isDebugging will be true
+
+    var resetState = function resetState() {
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref$isDebugging = _ref.isDebugging,
+          isDebugging = _ref$isDebugging === void 0 ? false : _ref$isDebugging;
+
+      var _this$state = _this.state,
+          calls = _this$state.calls,
+          shadowCalls = _this$state.shadowCalls,
+          callRefsByResult = _this$state.callRefsByResult,
+          chainedCallIds = _this$state.chainedCallIds,
+          playUntil = _this$state.playUntil;
+      var retainedCalls = (isDebugging ? shadowCalls : calls).filter(function (call) {
+        return call.retain;
+      });
+      var retainedCallRefs = new Map(Array.from(callRefsByResult.entries()).filter(function (_ref2) {
+        var _ref3 = _slicedToArray(_ref2, 2),
+            ref = _ref3[1];
+
+        return ref.retain;
+      }));
+
+      _this.setState(Object.assign({}, getInitialState(), {
+        cursor: retainedCalls.length,
+        calls: retainedCalls,
+        callRefsByResult: retainedCallRefs,
+        shadowCalls: isDebugging ? shadowCalls : [],
+        chainedCallIds: isDebugging ? chainedCallIds : new Set(),
+        playUntil: isDebugging ? playUntil : undefined,
+        isDebugging: isDebugging
+      })); // Don't sync while debugging, as it'll cause flicker.
+
+
+      if (!isDebugging) _this.channel.emit(EVENTS.SYNC, _this.getLog());
+    }; // A forceRemount might be triggered for debugging (on `start`), or elsewhere in Storybook.
+
+
+    this.channel.on(_coreEvents.FORCE_REMOUNT, resetState); // Start with a clean slate before playing, but also clean up when switching to a story that
+    // doesn't have a play function (in which case there is no 'playing' phase).
+    // Invocation of the play function is guaranteed to always be preceded by the 'rendering' phase.
+
+    this.channel.on(_coreEvents.STORY_RENDER_PHASE_CHANGED, function (_ref4) {
+      var storyId = _ref4.storyId,
+          newPhase = _ref4.newPhase;
+
+      // TODO keep state per story
+      if (newPhase === 'loading') {
+        resetState({
+          isDebugging: _this.state.isDebugging
+        });
+      }
+
+      if (newPhase === 'completed') {
+        _this.setState({
+          isDebugging: false
+        }); // Rethrow any unhandled forwarded exception so it doesn't go unnoticed.
+
+
+        if (_this.state.forwardedException) throw _this.state.forwardedException;
+      }
+    });
+
+    var start = function start(_ref5) {
+      var storyId = _ref5.storyId,
+          playUntil = _ref5.playUntil;
+
+      if (!_this.state.isDebugging) {
+        _this.setState(function (_ref6) {
+          var calls = _ref6.calls;
+          return {
+            calls: [],
+            shadowCalls: calls.map(function (call) {
+              return Object.assign({}, call, {
+                state: _types.CallStates.WAITING
+              });
+            }),
+            isDebugging: true
+          };
+        });
+      }
+
+      var log = _this.getLog();
+
+      var firstRowIndex = _this.state.shadowCalls.findIndex(function (call) {
+        return call.id === log[0].callId;
+      });
+
+      _this.setState(function (_ref7) {
+        var _shadowCalls$slice$fi;
+
+        var shadowCalls = _ref7.shadowCalls;
+        return {
+          playUntil: playUntil || ((_shadowCalls$slice$fi = shadowCalls.slice(0, firstRowIndex).filter(function (call) {
+            return call.interceptable;
+          }).slice(-1)[0]) === null || _shadowCalls$slice$fi === void 0 ? void 0 : _shadowCalls$slice$fi.id)
+        };
+      }); // Force remount may trigger a page reload if the play function can't be aborted.
+      // global.window.location.reload();
+
+
+      _this.channel.emit(_coreEvents.FORCE_REMOUNT, {
+        storyId: storyId,
+        isDebugging: true
+      });
+    };
+
+    var back = function back(_ref8) {
+      var _log, _log$slice$;
+
+      var storyId = _ref8.storyId;
+      var isDebugging = _this.state.isDebugging;
+
+      var log = _this.getLog();
+
+      var next = log.findIndex(function (_ref9) {
+        var state = _ref9.state;
+        return state === _types.CallStates.WAITING;
+      });
+      var playUntil = ((_log = log[next - 2]) === null || _log === void 0 ? void 0 : _log.callId) || (isDebugging ? null : (_log$slice$ = log.slice(-2)[0]) === null || _log$slice$ === void 0 ? void 0 : _log$slice$.callId);
+      start({
+        storyId: storyId,
+        playUntil: playUntil
+      });
+    };
+
+    var goto = function goto(_ref10) {
+      var storyId = _ref10.storyId,
+          callId = _ref10.callId;
+      var _this$state2 = _this.state,
+          calls = _this$state2.calls,
+          shadowCalls = _this$state2.shadowCalls,
+          resolvers = _this$state2.resolvers;
+      var call = calls.find(function (_ref11) {
+        var id = _ref11.id;
+        return id === callId;
+      });
+      var shadowCall = shadowCalls.find(function (_ref12) {
+        var id = _ref12.id;
+        return id === callId;
+      });
+
+      if (!call && shadowCall) {
+        var _this$getLog$find;
+
+        var nextCallId = (_this$getLog$find = _this.getLog().find(function (_ref13) {
+          var state = _ref13.state;
+          return state === _types.CallStates.WAITING;
+        })) === null || _this$getLog$find === void 0 ? void 0 : _this$getLog$find.callId;
+        if (shadowCall.id !== nextCallId) _this.setState({
+          playUntil: shadowCall.id
+        });
+        Object.values(resolvers).forEach(function (resolve) {
+          return resolve();
+        });
+      } else {
+        start({
+          storyId: storyId,
+          playUntil: callId
+        });
+      }
+    };
+
+    var next = function next() {
+      Object.values(_this.state.resolvers).forEach(function (resolve) {
+        return resolve();
+      });
+    };
+
+    var end = function end() {
+      _this.setState({
+        playUntil: undefined,
+        isDebugging: false
+      });
+
+      Object.values(_this.state.resolvers).forEach(function (resolve) {
+        return resolve();
+      });
+    };
+
+    this.channel.on(EVENTS.START, start);
+    this.channel.on(EVENTS.BACK, back);
+    this.channel.on(EVENTS.GOTO, goto);
+    this.channel.on(EVENTS.NEXT, next);
+    this.channel.on(EVENTS.END, end);
+  }
+
+  _createClass(Instrumenter, [{
+    key: "setState",
+    value: function setState(update) {
+      this.state = Object.assign({}, this.state, typeof update === 'function' ? update(this.state) : update); // Track state on the parent window so we can reload the iframe without losing state.
+
+      _global.default.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ = this.state;
+    }
+  }, {
+    key: "getLog",
+    value: function getLog() {
+      var merged = _toConsumableArray(this.state.shadowCalls);
+
+      this.state.calls.forEach(function (call, index) {
+        merged[index] = call;
+      });
+      var seen = new Set();
+      return merged.reduceRight(function (acc, call) {
+        call.args.forEach(function (arg) {
+          if (arg !== null && arg !== void 0 && arg.__callId__) {
+            seen.add(arg.__callId__);
+          }
+        });
+        call.path.forEach(function (node) {
+          if (node.__callId__) {
+            seen.add(node.__callId__);
+          }
+        });
+
+        if (call.interceptable && !seen.has(call.id) && !seen.has(call.parentId)) {
+          acc.unshift({
+            callId: call.id,
+            state: call.state
+          });
+          seen.add(call.id);
+
+          if (call.parentId) {
+            seen.add(call.parentId);
+          }
+        }
+
+        return acc;
+      }, []);
+    } // Traverses the object structure to recursively patch all function properties.
+    // Returns the original object, or a new object with the same constructor,
+    // depending on whether it should mutate.
+
+  }, {
+    key: "instrument",
+    value: function instrument(obj) {
+      var _this2 = this;
+
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!isInstrumentable(obj)) return obj;
+      var _options$mutate = options.mutate,
+          mutate = _options$mutate === void 0 ? false : _options$mutate,
+          _options$path = options.path,
+          path = _options$path === void 0 ? [] : _options$path;
+      return Object.keys(obj).reduce(function (acc, key) {
+        var value = obj[key]; // Nothing to patch, but might be instrumentable, so we recurse
+
+        if (typeof value !== 'function') {
+          acc[key] = _this2.instrument(value, Object.assign({}, options, {
+            path: path.concat(key)
+          }));
+          return acc;
+        } // Already patched, so we pass through unchanged
+
+
+        if (typeof value._original === 'function') {
+          acc[key] = value;
+          return acc;
+        } // Patch the function and mark it "patched" by adding a reference to the original function
+
+
+        acc[key] = _this2.patch(key, value, options);
+        acc[key]._original = value; // Deal with functions that also act like an object
+
+        if (Object.keys(value).length > 0) {
+          Object.assign(acc[key], _this2.instrument(Object.assign({}, value), Object.assign({}, options, {
+            path: path.concat(key)
+          })));
+        }
+
+        return acc;
+      }, mutate ? obj : construct(obj));
+    }
+  }, {
+    key: "patch",
+    value: function patch(method, fn, options) {
+      var _this3 = this;
+
+      var patched = function patched() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _this3.track(method, fn, args, options);
+      };
+
+      Object.defineProperty(patched, 'name', {
+        value: method,
+        writable: false
+      });
+      return patched;
+    } // Monkey patch an object method to record calls.
+    // Returns a function that invokes the original function, records the invocation ("call") and
+    // returns the original result.
+
+  }, {
+    key: "track",
+    value: function track(method, fn, args, _ref14) {
+      var _ref14$path = _ref14.path,
+          path = _ref14$path === void 0 ? [] : _ref14$path,
+          options = _objectWithoutProperties(_ref14, ["path"]);
+
+      var index = this.state.cursor;
+      this.setState({
+        cursor: this.state.cursor + 1
+      });
+      var id = "".concat(index, "-").concat(method);
+      var _options$intercept = options.intercept,
+          intercept = _options$intercept === void 0 ? false : _options$intercept,
+          _options$retain = options.retain,
+          retain = _options$retain === void 0 ? false : _options$retain;
+      var interceptable = typeof intercept === 'function' ? intercept(method, path) : intercept;
+      var call = {
+        id: id,
+        path: path,
+        method: method,
+        args: args,
+        interceptable: interceptable,
+        retain: retain
+      };
+      var result = (interceptable ? this.intercept : this.invoke).call(this, fn, call);
+      return this.instrument(result, Object.assign({}, options, {
+        mutate: true,
+        path: [{
+          __callId__: call.id
+        }]
+      }));
+    }
+  }, {
+    key: "intercept",
+    value: function intercept(fn, call) {
+      var _this4 = this;
+
+      // For a "jump to step" action, continue playing until we hit a call by that ID.
+      // For chained calls, we can only return a Promise for the last call in the chain.
+      var isChainedUpon = this.state.chainedCallIds.has(call.id);
+
+      if (!this.state.isDebugging || isChainedUpon || this.state.playUntil) {
+        if (this.state.playUntil === call.id) {
+          this.setState({
+            playUntil: undefined
+          });
+        }
+
+        return this.invoke(fn, call);
+      } // Instead of invoking the function, defer the function call until we continue playing.
+
+
+      return new Promise(function (resolve) {
+        _this4.setState(function (_ref15) {
+          var resolvers = _ref15.resolvers;
+          return {
+            resolvers: Object.assign({}, resolvers, _defineProperty({}, call.id, resolve))
+          };
+        });
+      }).then(function () {
+        var _this4$state$resolver = _this4.state.resolvers,
+            _call$id = call.id,
+            _ = _this4$state$resolver[_call$id],
+            resolvers = _objectWithoutProperties(_this4$state$resolver, [_call$id].map(_toPropertyKey));
+
+        _this4.setState({
+          resolvers: resolvers
+        });
+
+        return _this4.invoke(fn, call);
+      });
+    }
+  }, {
+    key: "invoke",
+    value: function invoke(fn, call) {
+      var _this5 = this;
+
+      var _this$state3 = this.state,
+          parentCallId = _this$state3.parentCallId,
+          callRefsByResult = _this$state3.callRefsByResult,
+          forwardedException = _this$state3.forwardedException;
+      var info = Object.assign({}, call, {
+        parentId: parentCallId,
+        // Map args that originate from a tracked function call to a call reference to enable nesting.
+        // These values are often not fully serializable anyway (e.g. HTML elements).
+        args: call.args.map(function (arg) {
+          if (callRefsByResult.has(arg)) {
+            return callRefsByResult.get(arg);
+          }
+
+          if (arg instanceof _global.default.window.HTMLElement) {
+            var prefix = arg.prefix,
+                localName = arg.localName,
+                id = arg.id,
+                classList = arg.classList,
+                innerText = arg.innerText;
+            var classNames = Array.from(classList);
+            return {
+              __element__: {
+                prefix: prefix,
+                localName: localName,
+                id: id,
+                classNames: classNames,
+                innerText: innerText
+              }
+            };
+          }
+
+          return arg;
+        })
+      }); // Mark any ancestor calls as "chained upon" so we won't attempt to defer it later.
+
+      call.path.forEach(function (ref) {
+        if (ref !== null && ref !== void 0 && ref.__callId__) {
+          _this5.setState(function (_ref16) {
+            var chainedCallIds = _ref16.chainedCallIds;
+            return {
+              chainedCallIds: new Set(Array.from(chainedCallIds).concat(ref.__callId__))
+            };
+          });
+        }
+      });
+
+      var handleException = function handleException(e) {
+        if (e instanceof Error) {
+          var name = e.name,
+              message = e.message,
+              stack = e.stack;
+          var exception = {
+            name: name,
+            message: message,
+            stack: stack,
+            callId: call.id
+          };
+
+          _this5.sync(Object.assign({}, info, {
+            state: _types.CallStates.ERROR,
+            exception: exception
+          })); // Always track errors to their originating call.
+
+
+          _this5.setState(function (state) {
+            return {
+              callRefsByResult: new Map([].concat(_toConsumableArray(Array.from(state.callRefsByResult.entries())), [[e, {
+                __callId__: call.id,
+                retain: call.retain
+              }]]))
+            };
+          }); // We need to throw to break out of the play function, but we don't want to trigger a redbox
+          // so we throw an ignoredException, which is caught and silently ignored by Storybook.
+
+
+          if (call.interceptable) {
+            throw _coreEvents.IGNORED_EXCEPTION;
+          } // Non-interceptable calls need their exceptions forwarded to the next interceptable call.
+          // In case no interceptable call picks it up, it'll get rethrown in the "completed" phase.
+
+
+          _this5.setState({
+            forwardedException: e
+          });
+
+          return e;
+        }
+
+        throw e;
+      };
+
+      try {
+        // An earlier, non-interceptable call might have forwarded an exception.
+        if (forwardedException) {
+          this.setState({
+            forwardedException: undefined
+          });
+          throw forwardedException;
+        }
+
+        var result = fn.apply(void 0, _toConsumableArray(call.args.map(function (arg) {
+          if (typeof arg !== 'function' || Object.keys(arg).length) return arg;
+          return function () {
+            var prev = _this5.state.parentCallId;
+
+            _this5.setState({
+              parentCallId: call.id
+            });
+
+            var res = arg.apply(void 0, arguments);
+
+            _this5.setState({
+              parentCallId: prev
+            });
+
+            return res;
+          };
+        }))); // Track the result so we can trace later uses of it back to the originating call.
+        // Primitive results (undefined, null, boolean, string, number, BigInt) are ignored.
+
+        if (result && ['object', 'function', 'symbol'].includes(_typeof(result))) {
+          this.setState(function (state) {
+            return {
+              callRefsByResult: new Map([].concat(_toConsumableArray(Array.from(state.callRefsByResult.entries())), [[result, {
+                __callId__: call.id,
+                retain: call.retain
+              }]]))
+            };
+          });
+        }
+
+        this.sync(Object.assign({}, info, {
+          state: result instanceof Promise ? _types.CallStates.ACTIVE : _types.CallStates.DONE
+        }));
+
+        if (result instanceof Promise) {
+          return result.then(function (value) {
+            _this5.sync(Object.assign({}, info, {
+              state: _types.CallStates.DONE
+            }));
+
+            return value;
+          }, handleException);
+        }
+
+        return result;
+      } catch (e) {
+        return handleException(e);
+      }
+    }
+  }, {
+    key: "sync",
+    value: function sync(call) {
+      var _this6 = this;
+
+      clearTimeout(this.state.syncTimeout);
+      this.channel.emit(EVENTS.CALL, call);
+      this.setState(function (_ref17) {
+        var calls = _ref17.calls;
+        return {
+          calls: calls.concat(call),
+          syncTimeout: setTimeout(function () {
+            return _this6.channel.emit(EVENTS.SYNC, _this6.getLog());
+          }, 0)
+        };
+      });
+    }
+  }]);
+
+  return Instrumenter;
+}();
+
+exports.Instrumenter = Instrumenter;
+var instrument = _global.default.window.parent === _global.default.window ? function (obj) {
+  return obj;
+} // Don't do anything if not loaded in an iframe.
+: function (obj) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (!_global.default.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__) _global.default.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ = new Instrumenter();
+  var instrumenter = _global.default.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__;
+  return instrumenter.instrument(obj, options);
+};
+exports.instrument = instrument;