@atlaskit/editor-plugin-type-ahead 0.5.0 → 0.7.0

package/dist/cjs/pm-plugins/key.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginKey = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var pluginKey = exports.pluginKey = new _state.PluginKey('typeAheadPlugin');

package/dist/cjs/pm-plugins/main.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPlugin = createPlugin;
+var _steps = require("@atlaskit/adf-schema/steps");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _utils = require("@atlaskit/editor-common/utils");
+var _view = require("@atlaskit/editor-prosemirror/view");
+var _constants = require("../constants");
+var _actions = require("./actions");
+var _decorations = require("./decorations");
+var _key = require("./key");
+var _reducer = require("./reducer");
+var _utils2 = require("./utils");
+var hasValidTypeAheadStep = function hasValidTypeAheadStep(tr) {
+  var steps = tr.steps.filter(function (step) {
+    return step instanceof _steps.InsertTypeAheadStep;
+  });
+
+  // There are some cases, like collab rebase, where the steps are re-applied
+  // We should not re open the type-ahead for those cases
+  if (steps.length === 1) {
+    return steps[0];
+  }
+  return null;
+};
+function createPlugin(_ref) {
+  var reactDispatch = _ref.reactDispatch,
+    popupMountRef = _ref.popupMountRef,
+    createAnalyticsEvent = _ref.createAnalyticsEvent,
+    typeAheadHandlers = _ref.typeAheadHandlers,
+    getIntl = _ref.getIntl;
+  var intl = getIntl();
+  var _factoryDecorations = (0, _decorations.factoryDecorations)({
+      intl: intl,
+      popupMountRef: popupMountRef,
+      createAnalyticsEvent: createAnalyticsEvent
+    }),
+    createDecorations = _factoryDecorations.createDecorations,
+    removeDecorations = _factoryDecorations.removeDecorations;
+  var reducer = (0, _reducer.createReducer)({
+    createDecorations: createDecorations,
+    removeDecorations: removeDecorations,
+    typeAheadHandlers: typeAheadHandlers,
+    popupMountRef: popupMountRef
+  });
+  return new _safePlugin.SafePlugin({
+    key: _key.pluginKey,
+    state: {
+      init: function init() {
+        return {
+          typeAheadHandlers: typeAheadHandlers,
+          query: '',
+          decorationSet: _view.DecorationSet.empty,
+          decorationElement: null,
+          items: [],
+          selectedIndex: -1,
+          stats: null,
+          inputMethod: null
+        };
+      },
+      apply: function apply(tr, currentPluginState, oldEditorState, state) {
+        var customStep = hasValidTypeAheadStep(tr);
+        var nextPluginState = reducer(tr, currentPluginState, customStep);
+        if (currentPluginState !== nextPluginState) {
+          reactDispatch(_key.pluginKey, nextPluginState);
+        }
+        return nextPluginState;
+      }
+    },
+    appendTransaction: function appendTransaction(transactions, _oldState, newState) {
+      var insertItemCallback = (0, _utils2.isInsertionTransaction)(transactions, _actions.ACTIONS.INSERT_RAW_QUERY);
+      if (insertItemCallback) {
+        var tr = insertItemCallback(newState);
+        if (tr) {
+          return tr;
+        }
+      }
+    },
+    view: function view() {
+      return {
+        update: function update(editorView) {}
+      };
+    },
+    props: {
+      decorations: function decorations(state) {
+        var _pluginKey$getState;
+        return (_pluginKey$getState = _key.pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.decorationSet;
+      },
+      handleDOMEvents: {
+        compositionend: function compositionend(view, event) {
+          return false;
+        },
+        click: function click(view, event) {
+          var target = event.target;
+          // ProseMirror view listen to any click event inside of it
+          // When this event is coming from the typeahead
+          // we should tell to ProseMirror to sit down and relax
+          // cuz we know what we are doing (I hope)
+          if (target instanceof HTMLElement && (0, _utils.closest)(target, "[data-type-ahead=".concat(_constants.TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE, "]"))) {
+            return true;
+          }
+          return false;
+        }
+      }
+    }
+  });
+}

package/dist/cjs/pm-plugins/reducer.js

@@ -0,0 +1,158 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReducer = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _steps = require("@atlaskit/adf-schema/steps");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _view = require("@atlaskit/editor-prosemirror/view");
+var _utils = require("../utils");
+var _actions = require("./actions");
+var _key = require("./key");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var shouldForceOpen = function shouldForceOpen(step) {
+  if (!(step instanceof _steps.InsertTypeAheadStep)) {
+    return false;
+  }
+  var isDeletionRawQueryOperation = step.isInsertionStep() && step.stage === _steps.InsertTypeAheadStages.DELETING_RAW_QUERY;
+  var isUndoingInsertionItem = step.isUndoingStep() && step.stage === _steps.InsertTypeAheadStages.INSERTING_ITEM;
+  return isDeletionRawQueryOperation || isUndoingInsertionItem;
+};
+var shouldForceClose = function shouldForceClose(step) {
+  if (!(step instanceof _steps.InsertTypeAheadStep)) {
+    return false;
+  }
+  var isInsertingItem = step.isInsertionStep() && step.stage === _steps.InsertTypeAheadStages.INSERTING_ITEM;
+  var isUndoingDeletionRawQuery = step.isUndoingStep() && step.stage === _steps.InsertTypeAheadStages.DELETING_RAW_QUERY;
+  return isInsertingItem || isUndoingDeletionRawQuery;
+};
+var createFindHandler = function createFindHandler(typeAheadHandlers) {
+  return function (step) {
+    if (!(step instanceof _steps.InsertTypeAheadStep)) {
+      return null;
+    }
+    var handler = typeAheadHandlers.find(function (h) {
+      return h.trigger === step.trigger;
+    });
+    return handler || null;
+  };
+};
+var createReducer = exports.createReducer = function createReducer(_ref) {
+  var typeAheadHandlers = _ref.typeAheadHandlers,
+    removeDecorations = _ref.removeDecorations,
+    createDecorations = _ref.createDecorations;
+  var findHandler = createFindHandler(typeAheadHandlers);
+  var openMenu = function openMenu(currentPluginState, _ref2) {
+    var tr = _ref2.tr,
+      triggerHandler = _ref2.triggerHandler,
+      inputMethod = _ref2.inputMethod,
+      reopenQuery = _ref2.reopenQuery,
+      selectedIndex = _ref2.selectedIndex;
+    removeDecorations(currentPluginState.decorationSet);
+    var _createDecorations = createDecorations(tr, {
+        triggerHandler: triggerHandler,
+        inputMethod: inputMethod,
+        reopenQuery: reopenQuery
+      }),
+      decorationSet = _createDecorations.decorationSet,
+      decorationElement = _createDecorations.decorationElement,
+      stats = _createDecorations.stats;
+    return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+      stats: stats,
+      decorationSet: decorationSet,
+      triggerHandler: triggerHandler,
+      decorationElement: decorationElement,
+      inputMethod: inputMethod,
+      selectedIndex: typeof selectedIndex === 'number' ? selectedIndex : -1,
+      items: [],
+      query: reopenQuery || ''
+    });
+  };
+  var closeMenu = function closeMenu(currentPluginState) {
+    removeDecorations(currentPluginState.decorationSet);
+    return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+      inputMethod: null,
+      query: '',
+      decorationElement: null,
+      decorationSet: _view.DecorationSet.empty,
+      stats: null,
+      triggerHandler: undefined,
+      items: []
+    });
+  };
+  return function (tr, currentPluginState, typeAheadStepOverride) {
+    var meta = tr.getMeta(_key.pluginKey) || {};
+
+    // This code below controls when we should force
+    // the menu to open or close during undo/redo operations
+    var overrideHandler = findHandler(typeAheadStepOverride);
+    if (typeAheadStepOverride && overrideHandler && shouldForceOpen(typeAheadStepOverride)) {
+      return openMenu(currentPluginState, {
+        tr: tr,
+        triggerHandler: overrideHandler,
+        inputMethod: _analytics.INPUT_METHOD.KEYBOARD,
+        reopenQuery: typeAheadStepOverride.query,
+        selectedIndex: typeAheadStepOverride.selectedIndex
+      });
+    } else if (shouldForceClose(typeAheadStepOverride)) {
+      return closeMenu(currentPluginState);
+    }
+    var _ref3 = meta || {},
+      action = _ref3.action,
+      params = _ref3.params;
+    var shouldOpenMenu = action === _actions.ACTIONS.OPEN_TYPEAHEAD_AT_CURSOR && (0, _utils.isTypeAheadHandler)(params === null || params === void 0 ? void 0 : params.triggerHandler);
+    var selectionChanged = tr.selectionSet && (tr.isGeneric || Boolean(tr.getMeta('pointer')));
+    var shouldCloseMenu = [_actions.ACTIONS.CLOSE_TYPE_AHEAD, _actions.ACTIONS.INSERT_ITEM].includes(action) || selectionChanged;
+    var shouldUpdateQuery = action === _actions.ACTIONS.CHANGE_QUERY;
+    var shouldUpdateListItems = action === _actions.ACTIONS.UPDATE_LIST_ITEMS;
+    var shouldUpdateSelectedIndex = action === _actions.ACTIONS.UPDATE_SELECTED_INDEX;
+    if (shouldOpenMenu) {
+      return openMenu(currentPluginState, {
+        tr: tr,
+        triggerHandler: params.triggerHandler,
+        inputMethod: params.inputMethod
+      });
+    } else if (shouldCloseMenu) {
+      return closeMenu(currentPluginState);
+    } else if (shouldUpdateQuery) {
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        query: params.query
+      });
+    } else if (shouldUpdateListItems) {
+      var items = params.items;
+      var selectedIndex = currentPluginState.selectedIndex;
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        items: items,
+        selectedIndex: Math.max(selectedIndex >= items.length ? items.length - 1 : selectedIndex, -1)
+      });
+    } else if (shouldUpdateSelectedIndex) {
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        selectedIndex: params.selectedIndex
+      });
+    }
+    if (tr.docChanged) {
+      var decorationSet = currentPluginState.decorationSet;
+      var onRemove = function onRemove() {
+        // Make sure we are unmounting the component
+        // from the react tree when this decoration is removed
+        removeDecorations(currentPluginState.decorationSet);
+      };
+      var mappedDecorationSet = decorationSet.map(tr.mapping, tr.doc, {
+        onRemove: onRemove
+      });
+
+      // return same pluginState if decorationSet did not change
+      if (mappedDecorationSet === currentPluginState.decorationSet) {
+        return currentPluginState;
+      }
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        decorationSet: mappedDecorationSet
+      });
+    }
+    return currentPluginState;
+  };
+};

package/dist/cjs/pm-plugins/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInsertionTransaction = void 0;
+var _key = require("./key");
+var isInsertionTransaction = exports.isInsertionTransaction = function isInsertionTransaction(transactions, action) {
+  var _tr$getMeta2;
+  var tr = transactions.find(function (tr) {
+    var _tr$getMeta;
+    return ((_tr$getMeta = tr.getMeta(_key.pluginKey)) === null || _tr$getMeta === void 0 ? void 0 : _tr$getMeta.action) === action;
+  });
+  if (!tr) {
+    return null;
+  }
+  return (_tr$getMeta2 = tr.getMeta(_key.pluginKey)) === null || _tr$getMeta2 === void 0 ? void 0 : _tr$getMeta2.params;
+};

package/dist/cjs/stats-modifier.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StatsModifier = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var StatsModifier = exports.StatsModifier = /*#__PURE__*/(0, _createClass2.default)(function StatsModifier() {
+  var _this = this;
+  (0, _classCallCheck2.default)(this, StatsModifier);
+  (0, _defineProperty2.default)(this, "startedAt", 0);
+  (0, _defineProperty2.default)(this, "endedAt", 0);
+  (0, _defineProperty2.default)(this, "keyCount", {
+    arrowUp: 0,
+    arrowDown: 0
+  });
+  (0, _defineProperty2.default)(this, "increaseArrowUp", function () {
+    _this.keyCount.arrowUp += 1;
+  });
+  (0, _defineProperty2.default)(this, "increaseArrowDown", function () {
+    _this.keyCount.arrowDown += 1;
+  });
+  (0, _defineProperty2.default)(this, "serialize", function () {
+    var _this$keyCount, _this$keyCount2;
+    return {
+      startedAt: _this.startedAt,
+      endedAt: performance.now(),
+      keyCount: {
+        arrowUp: ((_this$keyCount = _this.keyCount) === null || _this$keyCount === void 0 ? void 0 : _this$keyCount.arrowUp) || 0,
+        arrowDown: ((_this$keyCount2 = _this.keyCount) === null || _this$keyCount2 === void 0 ? void 0 : _this$keyCount2.arrowDown) || 0
+      }
+    };
+  });
+  this.startedAt = performance.now();
+  this.keyCount = {
+    arrowUp: 0,
+    arrowDown: 0
+  };
+});

package/dist/cjs/transforms/close-type-ahead.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.closeTypeAhead = void 0;
+var _actions = require("../pm-plugins/actions");
+var _key = require("../pm-plugins/key");
+var closeTypeAhead = exports.closeTypeAhead = function closeTypeAhead(tr) {
+  return tr.setMeta(_key.pluginKey, {
+    action: _actions.ACTIONS.CLOSE_TYPE_AHEAD
+  });
+};

package/dist/cjs/transforms/open-typeahead-at-cursor.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.openTypeAheadAtCursor = exports.openTypeAhead = void 0;
+var _selection = require("@atlaskit/editor-common/selection");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _actions = require("../pm-plugins/actions");
+var _key = require("../pm-plugins/key");
+var openTypeAhead = exports.openTypeAhead = function openTypeAhead(props) {
+  return function (tr) {
+    var triggerHandler = props.triggerHandler,
+      inputMethod = props.inputMethod,
+      query = props.query;
+    tr.setMeta(_key.pluginKey, {
+      action: _actions.ACTIONS.OPEN_TYPEAHEAD_AT_CURSOR,
+      params: {
+        triggerHandler: triggerHandler,
+        inputMethod: inputMethod,
+        query: query
+      }
+    });
+  };
+};
+var openTypeAheadAtCursor = exports.openTypeAheadAtCursor = function openTypeAheadAtCursor(_ref) {
+  var triggerHandler = _ref.triggerHandler,
+    inputMethod = _ref.inputMethod,
+    query = _ref.query;
+  return function (_ref2) {
+    var tr = _ref2.tr;
+    openTypeAhead({
+      triggerHandler: triggerHandler,
+      inputMethod: inputMethod,
+      query: query
+    })(tr);
+    var selection = tr.selection;
+    if (!(selection instanceof _state.TextSelection || selection instanceof _selection.GapCursorSelection)) {
+      return tr;
+    }
+    if (selection instanceof _selection.GapCursorSelection) {
+      // Create space for the typeahead menu in gap cursor
+      tr.insertText(' ');
+      // delete 1 pos before wherever selection is now - that will delete the empty space
+      tr.delete(tr.selection.from - 1, tr.selection.from);
+    } else {
+      var _selection$$head, _selection$$head$pare, _selection$$head$pare2;
+      if (!selection.$cursor) {
+        tr.deleteSelection();
+        return tr;
+      }
+
+      // Search & Destroy placeholder
+      var cursorPos = selection.$cursor.pos;
+      var nodeAtCursor = tr.doc.nodeAt(cursorPos);
+      var isPlaceholderAtCursorPosition = nodeAtCursor && nodeAtCursor.type.name === 'placeholder';
+      if (nodeAtCursor && isPlaceholderAtCursorPosition) {
+        tr.delete(cursorPos, cursorPos + nodeAtCursor.nodeSize);
+      }
+
+      // ME-2375 remove the superfluous '@' inserted before decoration
+      // by composition (https://github.com/ProseMirror/prosemirror/issues/903)
+      //
+      // Update:
+      // Now also handles any use case with superfluous typeahead triggers (ie. '@', ':', '/')
+      // being inserted due to composition by checking if we have the trigger
+      // directly before the typeahead. This should not happen unless it has
+      // been eroneously added because we require whitespace/newline for typeahead.
+      if (cursorPos >= 2 && !!(selection !== null && selection !== void 0 && (_selection$$head = selection.$head) !== null && _selection$$head !== void 0 && (_selection$$head = _selection$$head.parent) !== null && _selection$$head !== void 0 && _selection$$head.textContent) && (_selection$$head$pare = (_selection$$head$pare2 = selection.$head.parent.textContent).endsWith) !== null && _selection$$head$pare !== void 0 && _selection$$head$pare.call(_selection$$head$pare2, triggerHandler.trigger)) {
+        tr.delete(cursorPos - 1, cursorPos);
+      }
+    }
+    return tr;
+  };
+};

package/dist/cjs/transforms/set-selection-before-query.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setSelectionBeforeQuery = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var setSelectionBeforeQuery = exports.setSelectionBeforeQuery = function setSelectionBeforeQuery(rawText) {
+  return function (tr) {
+    var currentPosition = tr.selection.$from.pos;
+    var positionBeforeRawText = Math.max(currentPosition - rawText.length, 0);
+    var resolvedPositionBeforeText = tr.doc.resolve(positionBeforeRawText);
+    var nextSelection = _state.TextSelection.findFrom(resolvedPositionBeforeText, -1, true);
+    if (nextSelection) {
+      tr.setSelection(nextSelection);
+    }
+  };
+};

package/dist/cjs/ui/AssistiveText.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssistiveText = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@emotion/react");
+var _debounce = _interopRequireDefault(require("lodash/debounce"));
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } } /** @jsx jsx */
+var statusDebounceMillis = 1400;
+var assitiveTextStyles = (0, _react2.css)({
+  border: 0,
+  clip: 'rect(0 0 0 0)',
+  height: '1px',
+  marginbottom: '-1px',
+  marginright: '-1px',
+  overflow: 'hidden',
+  padding: 0,
+  position: 'absolute',
+  whitespace: 'nowrap',
+  width: '1px'
+});
+var AssistveTextComponent = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2.default)(AssistveTextComponent, _React$Component);
+  var _super = _createSuper(AssistveTextComponent);
+  function AssistveTextComponent() {
+    var _this;
+    (0, _classCallCheck2.default)(this, AssistveTextComponent);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "state", {
+      bump: false,
+      //when the same text needs to be read again, Hence it needs to be toggled between __status--A and __status--B
+      debounced: false,
+      silenced: false
+    });
+    return _this;
+  }
+  (0, _createClass2.default)(AssistveTextComponent, [{
+    key: "componentWillMount",
+    value: function componentWillMount() {
+      var _this2 = this;
+      this.debounceStatusUpdate = (0, _debounce.default)(function () {
+        if (!_this2.state.debounced) {
+          var shouldSilence = !_this2.props.isInFocus;
+          _this2.setState(function (_ref) {
+            var bump = _ref.bump;
+            return {
+              bump: !bump,
+              debounced: true,
+              silenced: shouldSilence
+            };
+          });
+        }
+      }, statusDebounceMillis);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.debounceStatusUpdate.cancel();
+    }
+  }, {
+    key: "componentWillReceiveProps",
+    value: function componentWillReceiveProps() {
+      this.setState(function (_ref2) {
+        var bump = _ref2.bump;
+        return {
+          bump: !bump,
+          debounced: false
+        };
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        assistiveText = _this$props.assistiveText,
+        id = _this$props.id;
+      var _this$state = this.state,
+        bump = _this$state.bump,
+        debounced = _this$state.debounced,
+        silenced = _this$state.silenced;
+      this.debounceStatusUpdate();
+      return (0, _react2.jsx)("div", {
+        css: assitiveTextStyles
+      }, (0, _react2.jsx)("div", {
+        id: id + '__status--A',
+        role: "status",
+        "aria-atomic": "true",
+        "aria-live": "polite"
+      }, "".concat(!silenced && debounced && bump ? assistiveText : '')), (0, _react2.jsx)("div", {
+        id: id + '__status--B',
+        role: "status",
+        "aria-atomic": "true",
+        "aria-live": "polite"
+      }, "".concat(!silenced && debounced && !bump ? assistiveText : '')));
+    }
+  }]);
+  return AssistveTextComponent;
+}(_react.default.Component);
+(0, _defineProperty2.default)(AssistveTextComponent, "defaultProps", {
+  statusDebounceMillis: 1400,
+  debounce: true,
+  assistiveText: '',
+  isInFocus: false,
+  id: ''
+});
+var AssistiveText = exports.AssistiveText = AssistveTextComponent;