@atlaskit/reactions 21.5.1 → 21.6.0

package/dist/esm/containers/ConnectedReactionsView/ConnectedReactionsView.js

@@ -0,0 +1,227 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { FabricElementsAnalyticsContext } from '@atlaskit/analytics-namespaced-context';
+import { useAnalyticsEvents } from '@atlaskit/analytics-next';
+import { Reactions, UfoErrorBoundary } from '../../components';
+import { ufoExperiences } from '../../store';
+import { ReactionStatus } from '../../types';
+
+/**
+ * Export the mapper function outside the component so easier to do unit tests migration from Enzyme to React Testing Library
+ */
+export var mapStateToPropsHelper = function mapStateToPropsHelper(containerAri, ari, state) {
+  var reactionsState = state && state.reactions["".concat(containerAri, "|").concat(ari)];
+
+  if (!state || !reactionsState) {
+    return {
+      status: ReactionStatus.notLoaded,
+      reactions: []
+    };
+  }
+
+  switch (reactionsState.status) {
+    case ReactionStatus.ready:
+      return {
+        reactions: reactionsState.reactions,
+        status: reactionsState.status,
+        flash: state.flash["".concat(containerAri, "|").concat(ari)]
+      };
+
+    case ReactionStatus.error:
+      return {
+        status: ReactionStatus.error,
+        reactions: []
+      };
+
+    default:
+      return {
+        status: ReactionStatus.loading,
+        reactions: []
+      };
+  }
+};
+/**
+ * Export the mapper function outside the component so easier to do unit tests migration from Enzyme to React Testing Library
+ */
+
+export var mapDispatchToPropsHelper = function mapDispatchToPropsHelper(actions, containerAri, ari) {
+  return {
+    loadReaction: function loadReaction() {
+      actions.getReactions(containerAri, ari);
+    },
+    onReactionClick: function onReactionClick(emojiId) {
+      actions.toggleReaction(containerAri, ari, emojiId);
+    },
+    onReactionHover: function onReactionHover(emojiId) {
+      actions.getDetailedReaction(containerAri, ari, emojiId);
+    },
+    onSelection: function onSelection(emojiId) {
+      actions.addReaction(containerAri, ari, emojiId);
+    }
+  };
+};
+export var ConnectedReactionsView = function ConnectedReactionsView(props) {
+  var ari = props.ari,
+      containerAri = props.containerAri,
+      store = props.store;
+  /**
+   * Reference to the <Reactions /> component instance mandatory props
+   */
+
+  var _useState = useState(),
+      _useState2 = _slicedToArray(_useState, 2),
+      stateData = _useState2[0],
+      setStateData = _useState2[1];
+
+  var _useState3 = useState(),
+      _useState4 = _slicedToArray(_useState3, 2),
+      dispatchData = _useState4[0],
+      setDispatchData = _useState4[1]; // compose a UFO experience object
+
+
+  var experienceInstance = useRef();
+
+  var _useAnalyticsEvents = useAnalyticsEvents(),
+      createAnalyticsEvent = _useAnalyticsEvents.createAnalyticsEvent;
+
+  useEffect(function () {
+    experienceInstance.current = ufoExperiences.render(ari);
+  }, [ari]); // abort when component gets unmounted
+
+  useEffect(function () {
+    return function cleanup() {
+      var _experienceInstance$c;
+
+      (_experienceInstance$c = experienceInstance.current) === null || _experienceInstance$c === void 0 ? void 0 : _experienceInstance$c.abort({
+        metadata: {
+          source: 'Connected-Reactions-View',
+          data: {
+            ari: ari,
+            containerAri: containerAri
+          },
+          reason: 'unmount'
+        }
+      });
+    };
+  }, [experienceInstance, containerAri, ari]);
+  /**
+   * Maps the store instance "reactions" data to the <Reactions /> component state data
+   * @param state store instance latest data
+   */
+
+  var mapStateToProps = useCallback(function (state) {
+    return mapStateToPropsHelper(containerAri, ari, state);
+  }, [containerAri, ari]);
+  /**
+   * Map the store instance "actions" methods to the <Reactions /> component actions methods
+   * @param actions list of actions in the store instance
+   */
+
+  var mapDispatchToProps = useCallback(function (actions) {
+    return mapDispatchToPropsHelper(actions, containerAri, ari);
+  }, [ari, containerAri]);
+  useEffect(function () {
+    _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var _store, state, dispatch;
+
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return Promise.resolve(store);
+
+            case 2:
+              _store = _context.sent;
+
+              if (_store.setCreateAnalyticsEvent && createAnalyticsEvent) {
+                _store.setCreateAnalyticsEvent(createAnalyticsEvent);
+              }
+
+              state = mapStateToProps(_store.getState());
+              dispatch = mapDispatchToProps(_store);
+              setStateData(state);
+              setDispatchData(dispatch);
+
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }))();
+  }, [createAnalyticsEvent, store, ari, containerAri, mapStateToProps, mapDispatchToProps]);
+  /**
+   * Listen to changes on the store data.
+   * TODO: Needs to be refactored inside the MemoryReactionsStore to different pattern, currently it relies on internal callbacks variable to trigger changes to the store.
+   * The flow that each action method triggers a call to "setState" => "triggerOnChange" => calls the callback function registered by the onChange method and de-register by the "removeOnChangeListener" method
+   */
+
+  useEffect(function () {
+    var onChangeCallback = function onChangeCallback(state) {
+      var stateProps = mapStateToProps(state);
+      setStateData(stateProps);
+    };
+
+    _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var _store;
+
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return Promise.resolve(store);
+
+            case 2:
+              _store = _context2.sent;
+
+              _store.onChange(onChangeCallback);
+
+            case 4:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }))();
+
+    return function cleanup() {
+      _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var _store;
+
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return Promise.resolve(store);
+
+              case 2:
+                _store = _context3.sent;
+
+                _store.removeOnChangeListener(onChangeCallback);
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }))();
+    };
+  }, [mapStateToProps, store]);
+  return /*#__PURE__*/React.createElement(FabricElementsAnalyticsContext, {
+    data: {
+      containerAri: containerAri,
+      ari: ari
+    }
+  }, /*#__PURE__*/React.createElement(UfoErrorBoundary, {
+    experiences: experienceInstance.current ? [experienceInstance.current] : []
+  }, stateData && dispatchData ? /*#__PURE__*/React.createElement(Reactions, _extends({
+    key: "".concat(props.containerAri, "|").concat(props.ari)
+  }, props, dispatchData, stateData)) : null));
+};

package/dist/esm/containers/ConnectedReactionsView/index.js

@@ -0,0 +1 @@
+export { ConnectedReactionsView } from './ConnectedReactionsView';

package/dist/esm/containers/index.js

@@ -1,2 +1,2 @@
-export { ConnectedReactionPicker } from './ConnectedReactionPicker';
-export { ConnectedReactionsView } from './ConnectedReactionsView';
+export * from './ConnectedReactionPicker';
+export * from './ConnectedReactionsView';

package/dist/esm/hooks/index.js

@@ -0,0 +1 @@
+export { useClickAway } from './useClickAway';

package/dist/esm/hooks/useClickAway.js

@@ -0,0 +1,28 @@
+import { useEffect } from 'react';
+/**
+ * Custom hook to detect when user action is outside given container ref
+ * @param ref ref object to an html element
+ * @param callback event callback when detected a click outside the ref object
+ * @param type (Optional) type of event to listen to. @default click
+ */
+
+export function useClickAway(ref, callback) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'click';
+  useEffect(function () {
+    /**
+     * Alert if clicked on outside of element
+     */
+    function handleClickOutside(event) {
+      if (ref.current && event.target instanceof Node && !ref.current.contains(event.target)) {
+        callback();
+      }
+    } // Bind the event listener
+
+
+    document.addEventListener(type, handleClickOutside);
+    return function () {
+      // Unbind the event listener on clean up
+      document.removeEventListener(type, handleClickOutside);
+    };
+  }, [ref, callback, type]);
+}

package/dist/esm/index.js

@@ -1,5 +1,7 @@
 export { UFO } from './analytics';
-export { ReactionServiceClient } from './client';
+export { ReactionServiceClient } from './client'; // TODO: Convert all calls for ReactionRequest to Request, RequestClient to Client and ReactionsStore to Store
+
+export { constants } from './shared';
 export { Reaction, ReactionPicker, Reactions } from './components';
 export { ConnectedReactionPicker, ConnectedReactionsView } from './containers';
 export { MemoryReactionsStore, ReactionConsumer } from './store';

package/dist/esm/shared/constants.js

@@ -1,4 +1,34 @@
-// site id for jdog.jira-dev.com
-export var demoCloudId = "49d8b9d6-ee7d-4931-a0ca-7fcae7d1c3b5";
-export var AriPrefix = "ari:cloud:test:".concat(demoCloudId, ":item/");
-export var ContainerAriPrefix = "ari:cloud:test:".concat(demoCloudId, ":container/");
+/**
+ * Initial list of emoji to pick from
+ */
+export var DefaultReactions = [{
+  id: '1f44d',
+  shortName: ':thumbsup:'
+}, {
+  id: '1f44f',
+  shortName: ':clap:'
+}, {
+  id: '1f525',
+  shortName: ':fire:'
+}, {
+  id: '2764',
+  shortName: ':heart:'
+}, {
+  id: '1f632',
+  shortName: ':astonished:'
+}, {
+  id: '1f914',
+  shortName: ':thinking:'
+}];
+/**
+ * ES6 Map object from default emoji reactions (with key => shortName, value => entire emoji item)
+ */
+
+export var DefaultReactionsByShortName = new Map(DefaultReactions.map(function (reaction) {
+  return [reaction.shortName, reaction];
+}));
+/**
+ * Maximum number of users to show in the tooltip for an emoji reaction
+ */
+
+export var TOOLTIP_USERS_LIMIT = 5;

package/dist/esm/{components → shared}/i18n.js

@@ -12,7 +12,7 @@ export var messages = defineMessages({
   },
   unexpectedError: {
     id: 'fabric.reactions.error.unexpected',
-    defaultMessage: 'Something went wrong',
+    defaultMessage: 'Reactions are temporarily unavailable',
     description: 'Unexpected error message'
   },
   otherUsers: {

package/dist/esm/shared/index.js

@@ -1,2 +1,6 @@
-import * as _Constants from './constants';
-export { _Constants as Constants };
+import * as _constants from './constants';
+export { _constants as constants };
+import * as _utils from './utils';
+export { _utils as utils };
+import * as _i18n from './i18n';
+export { _i18n as i18n };

package/dist/esm/shared/utils.js

@@ -0,0 +1,41 @@
+import { DefaultReactions } from './constants';
+/**
+ * Is selected mouse event a left click
+ * @param event event data
+ */
+
+export var isLeftClick = function isLeftClick(event) {
+  return event.button === 0 && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey;
+};
+/**
+ * Does provided item part of the default emoji ids
+ * @param item selected emoji item
+ */
+
+export var isDefaultReaction = function isDefaultReaction(item) {
+  return DefaultReactions.some(function (otherEmojiId) {
+    return isEqualEmojiId(otherEmojiId, item);
+  });
+};
+/**
+ * compare 2 emoji items if they are same input
+ * @param a first emoji item
+ * @param b second emoji item
+ */
+
+var isEqualEmojiId = function isEqualEmojiId(a, b) {
+  if (isEmojiId(a) && isEmojiId(b)) {
+    return a === b || a && b && a.id === b.id && a.shortName === b.shortName;
+  } else {
+    return a === b;
+  }
+};
+/**
+ * Type guard if provided object is a string id or an object info collection for the emoji
+ * @param item given item
+ */
+
+
+var isEmojiId = function isEmojiId(item) {
+  return item.id !== undefined;
+};

package/dist/esm/store/{ReactionsStore.js → MemoryReactionsStore.js}

@@ -6,30 +6,27 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-import * as Analytics from '../analytics';
+import { Analytics, UFO } from '../analytics';
 import * as Types from '../types';
 import { batch, batchByKey } from './batched';
 import * as utils from './utils';
 import { isRealErrorFromService } from './utils';
 import { SAMPLING_RATE_REACTIONS_RENDERED_EXP } from '../analytics/constants';
 import { sampledReactionsRendered } from '../analytics/ufo';
-/**
- * store main structure
- */
-
 /**
  * Set of all available UFO experiences relating to reaction element
  */
+
 export var ufoExperiences = {
   /**
    * Experience when a reaction emoji gets added
    */
-  add: Analytics.UFO.ReactionsAdd,
+  add: UFO.ReactionsAdd,
 
   /**
    * Experience when a reaction emoji gets removed/decrement
    */
-  remove: Analytics.UFO.ReactionsRemove,
+  remove: UFO.ReactionsRemove,
 
   /**
    * Experience when the list of reactions gets rendered with sampling
@@ -41,26 +38,28 @@ export var ufoExperiences = {
   /**
    * Experience when a reaction details gets fetched
    */
-  fetchDetails: Analytics.UFO.ReactionDetailsFetch
+  fetchDetails: UFO.ReactionDetailsFetch
 };
 /**
- * Collection of methods to manage internal state across the different Reaction container components ConnectedReactionPicker and ConnectedReactionsView
+ * Optional metadata information in the store used in sending the API client requests
  */
 
 export var MemoryReactionsStore = /*#__PURE__*/function () {
-  function MemoryReactionsStore(client) {
+  /**
+   * default initial store data
+   */
+  function MemoryReactionsStore(client, state, metadata) {
     var _this = this;
 
-    var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      reactions: {},
-      flash: {}
-    };
-    var metadata = arguments.length > 2 ? arguments[2] : undefined;
-
     _classCallCheck(this, MemoryReactionsStore);
 
     _defineProperty(this, "callbacks", []);
 
+    _defineProperty(this, "initialState", {
+      reactions: {},
+      flash: {}
+    });
+
     _defineProperty(this, "setState", function (newState) {
       _this.state = _objectSpread(_objectSpread({}, _this.state), newState);
 
@@ -160,7 +159,7 @@ export var MemoryReactionsStore = /*#__PURE__*/function () {
 
         exp.success();
       }).catch(function (error) {
-        if (_this.createAnalyticsEvent && isRealErrorFromService(error.code)) {
+        if (isRealErrorFromService(error.code)) {
           _this.createAnalyticsEvent && Analytics.createAndFireSafe(_this.createAnalyticsEvent, Analytics.createRestFailedEvent, 'addReaction', error.code); // ufo add reaction failure
 
           exp.failure({
@@ -246,7 +245,7 @@ export var MemoryReactionsStore = /*#__PURE__*/function () {
       }).catch(function (error) {
         if (isRealErrorFromService(error.code)) {
           if (_this.createAnalyticsEvent) {
-            Analytics.createAndFireSafe(_this.createAnalyticsEvent, Analytics.createRestFailedEvent, 'getReactions', error.code);
+            Analytics.createAndFireSafe(_this.createAnalyticsEvent, Analytics.createRestFailedEvent, 'getReactions');
           }
 
           sampledExp.failure({
@@ -260,8 +259,20 @@ export var MemoryReactionsStore = /*#__PURE__*/function () {
               reason: 'getReactions fetch failed'
             }
           });
-          return Promise.reject(error);
         }
+
+        var reactionsState = arisArr.reduce(function (acc, ari) {
+          return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, "".concat(containerAri, "|").concat(ari), {
+            reactions: [],
+            status: Types.ReactionStatus.error
+          }));
+        }, {});
+
+        _this.setState(_objectSpread(_objectSpread({}, _this.state), {}, {
+          reactions: _objectSpread(_objectSpread({}, _this.state.reactions), reactionsState)
+        }));
+
+        return Promise.reject(error);
       });
     }));
 
@@ -310,9 +321,14 @@ export var MemoryReactionsStore = /*#__PURE__*/function () {
     });
 
     this.client = client;
-    this.state = state;
+    this.state = state !== null && state !== void 0 ? state : this.initialState;
     this.metadata = metadata;
   }
+  /**
+   * Update the store state data with a new data
+   * @param newState new store data
+   */
+
 
   _createClass(MemoryReactionsStore, [{
     key: "getReactionsState",

package/dist/esm/store/ReactionConsumer.js

@@ -1,3 +1,4 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
@@ -5,12 +6,18 @@ import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 import React from 'react';
+
+/**
+ * A custom mapper class that takes the store instance and mapper functions "mapStateToProps" and "mapActionsToProps" to return the renderProps pattern as a child component
+ * @deprecated please avoid using this class as it will be removed in a future release
+ */
 export var ReactionConsumer = /*#__PURE__*/function (_React$PureComponent) {
   _inherits(ReactionConsumer, _React$PureComponent);
 
@@ -24,11 +31,11 @@ export var ReactionConsumer = /*#__PURE__*/function (_React$PureComponent) {
     _this = _super.call(this, props);
 
     _defineProperty(_assertThisInitialized(_this), "getPropsFromActions", function (actions) {
-      var actionsMapper = _this.props.actionsMapper;
+      var mapActionsToProps = _this.props.mapActionsToProps;
 
-      if (actionsMapper) {
+      if (mapActionsToProps) {
         if (!_this.previousActions || !_this.propsFromActions || _this.previousActions !== actions) {
-          _this.propsFromActions = actionsMapper(actions);
+          _this.propsFromActions = mapActionsToProps(actions);
         }
       }
 
@@ -37,20 +44,17 @@ export var ReactionConsumer = /*#__PURE__*/function (_React$PureComponent) {
     });
 
     _defineProperty(_assertThisInitialized(_this), "getPropsFromState", function (state) {
-      var stateMapper = _this.props.stateMapper;
-
-      if (stateMapper) {
-        return stateMapper(state);
-      }
-
-      return undefined;
+      var mapStateToProps = _this.props.mapStateToProps;
+      return mapStateToProps ? mapStateToProps(state) : undefined;
     });
 
     _defineProperty(_assertThisInitialized(_this), "handleOnChange", function () {
       _this.forceUpdate();
     });
 
-    _this.state = {};
+    _this.state = {
+      store: undefined
+    };
     return _this;
   }
 
@@ -69,11 +73,34 @@ export var ReactionConsumer = /*#__PURE__*/function (_React$PureComponent) {
     }
   }, {
     key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      if (this.state.store) {
-        this.state.store.removeOnChangeListener(this.handleOnChange);
+    value: function () {
+      var _componentWillUnmount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (this.state.store) {
+                  this.state.store.removeOnChangeListener(this.handleOnChange);
+                }
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function componentWillUnmount() {
+        return _componentWillUnmount.apply(this, arguments);
       }
-    }
+
+      return componentWillUnmount;
+    }()
+    /**
+     * Get the actions the child component might need to dispatch from its props
+     */
+
   }, {
     key: "render",
     value: function render() {

package/dist/esm/store/index.js

@@ -1,2 +1,2 @@
 export { ReactionConsumer } from './ReactionConsumer';
-export { MemoryReactionsStore } from './ReactionsStore';
+export { MemoryReactionsStore, ufoExperiences } from './MemoryReactionsStore';

package/dist/esm/store/utils.js

@@ -4,11 +4,13 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-import { ReactionStatus } from '../types/ReactionStatus';
-export var compareEmojiId = function compareEmojiId(l, r) {
+import { ReactionStatus } from '../types';
+
+var compareEmojiId = function compareEmojiId(l, r) {
   return l.localeCompare(r);
 };
-export var sortByRelevance = function sortByRelevance(a, b) {
+
+var sortByRelevance = function sortByRelevance(a, b) {
   if (a.count > b.count) {
     return -1;
   } else if (a.count < b.count) {
@@ -17,7 +19,8 @@ export var sortByRelevance = function sortByRelevance(a, b) {
     return compareEmojiId(a.emojiId, b.emojiId);
   }
 };
-export var sortByPreviousPosition = function sortByPreviousPosition(reactions) {
+
+var sortByPreviousPosition = function sortByPreviousPosition(reactions) {
   var indexes = reactions.reduce(function (map, reaction, index) {
     map[reaction.emojiId] = index;
     return map;
@@ -32,6 +35,7 @@ export var sortByPreviousPosition = function sortByPreviousPosition(reactions) {
     return getPosition(a) - getPosition(b);
   };
 };
+
 export var readyState = function readyState(reactions) {
   return {
     status: ReactionStatus.ready,

package/dist/esm/types/index.js

@@ -1 +1 @@
-export { ReactionStatus } from './ReactionStatus';
+export { ReactionStatus } from './reaction';