@atlaskit/editor-core 148.0.0 → 149.0.3

package/dist/cjs/plugins/type-ahead/pm-plugins/input-rules.js

@@ -1,64 +1,44 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.inputRulePlugin = inputRulePlugin;
-exports.default = exports.typeAheadInputRulesPluginKey = void 0;
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _inputRules = require("../../../utils/input-rules");
+exports.default = void 0;
 
 var _prosemirrorInputRules = require("@atlaskit/prosemirror-input-rules");
 
-var _main = require("./main");
+var _openTypeaheadAtCursor = require("../transforms/open-typeahead-at-cursor");
 
-// We cannot set a proper plugin key on input rule plugins, so instead, once
-// the plugin is created we save its key to this variable
-var typeAheadInputRulesPluginKey = '';
-exports.typeAheadInputRulesPluginKey = typeAheadInputRulesPluginKey;
+var _analytics = require("../../analytics");
 
-function inputRulePlugin(schema, typeAheads, featureFlags) {
-  var triggersRegex = typeAheads.map(function (t) {
-    return t.customRegex || t.trigger;
-  }).join('|');
+var _inputRules = require("../../../utils/input-rules");
 
-  if (!triggersRegex.length) {
+function inputRulePlugin(schema, typeAheads, featureFlags) {
+  if (!typeAheads || typeAheads.length === 0) {
     return;
   }
 
-  var regex = new RegExp("(^|[.!?\\s".concat(_prosemirrorInputRules.leafNodeReplacementCharacter, "])(").concat(triggersRegex, ")$"));
-  var typeAheadInputRule = (0, _inputRules.createRule)(regex, function (state, match) {
-    var typeAheadState = _main.pluginKey.getState(state);
-    /**
-     * Why using match 2 and 3?  Regex:
-     * (allowed characters before trigger)(joined|triggers|(sub capture groups))
-     *            match[1]                     match[2]          match[3] – optional
-     */
-
+  var rules = typeAheads.reduce(function (acc, typeAhead) {
+    var trigger = typeAhead.customRegex || typeAhead.trigger;
 
-    var trigger = match[3] || match[2];
-
-    if (!typeAheadState.isAllowed || !trigger) {
-      return null;
+    if (!trigger) {
+      return acc;
     }
 
-    var mark = schema.mark('typeAheadQuery', {
-      trigger: trigger
-    });
-    var tr = state.tr,
-        selection = state.selection;
-    var marks = selection.$from.marks();
-    return tr.replaceSelectionWith(schema.text(trigger, [mark].concat((0, _toConsumableArray2.default)(marks))), false);
-  });
-  var plugin = (0, _inputRules.createPlugin)('type-ahead', [typeAheadInputRule], {
+    var regex = new RegExp("(^|[.!?\\s".concat(_prosemirrorInputRules.leafNodeReplacementCharacter, "])(").concat(trigger, ")$"));
+    acc.push((0, _inputRules.createRule)(regex, function (state, match) {
+      return (0, _openTypeaheadAtCursor.openTypeAheadAtCursor)({
+        triggerHandler: typeAhead,
+        inputMethod: _analytics.INPUT_METHOD.KEYBOARD
+      })(state.tr);
+    }));
+    return acc;
+  }, []);
+  var plugin = (0, _inputRules.createPlugin)('type-ahead', rules, {
     allowInsertTextOnDocument: false,
     useUnpredictableInputRule: featureFlags.useUnpredictableInputRule
   });
-  exports.typeAheadInputRulesPluginKey = typeAheadInputRulesPluginKey = plugin.key;
   return plugin;
 }
 

package/dist/cjs/plugins/type-ahead/pm-plugins/insert-item-plugin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPlugin = createPlugin;
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _actions = require("./actions");
+
+var _utils = require("./utils");
+
+function createPlugin() {
+  return new _prosemirrorState.Plugin({
+    appendTransaction: function appendTransaction(transactions, _oldState, newState) {
+      var insertItemCallback = (0, _utils.isInsertionTransaction)(transactions, _actions.ACTIONS.INSERT_ITEM);
+
+      if (insertItemCallback) {
+        var tr = insertItemCallback(newState);
+
+        if (tr) {
+          return tr;
+        }
+      }
+    }
+  });
+}

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

@@ -1,252 +1,123 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createInitialPluginState = createInitialPluginState;
 exports.createPlugin = createPlugin;
-exports.createItemsLoader = createItemsLoader;
-exports.defaultActionHandler = defaultActionHandler;
-exports.setCurrentItemIndex = setCurrentItemIndex;
-exports.updateQueryHandler = updateQueryHandler;
-exports.selectPrevActionHandler = selectPrevActionHandler;
-exports.selectNextActionHandler = selectNextActionHandler;
-exports.itemsListUpdatedActionHandler = itemsListUpdatedActionHandler;
-exports.selectCurrentActionHandler = selectCurrentActionHandler;
-Object.defineProperty(exports, "ACTIONS", {
-  enumerable: true,
-  get: function get() {
-    return _actions.ACTIONS;
-  }
-});
-Object.defineProperty(exports, "pluginKey", {
-  enumerable: true,
-  get: function get() {
-    return _pluginKey.pluginKey;
-  }
-});
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _prosemirrorState = require("prosemirror-state");
 
-var _utils = require("../../../utils");
-
-var _dismiss = require("../commands/dismiss");
+var _prosemirrorView = require("prosemirror-view");
 
-var _insertQuery = require("../commands/insert-query");
+var _steps = require("@atlaskit/adf-schema/steps");
 
-var _itemsListUpdated = require("../commands/items-list-updated");
+var _constants = require("../constants");
 
-var _selectItem = require("../commands/select-item");
+var _actions = require("./actions");
 
-var _updateQuery = require("../commands/update-query");
+var _key = require("./key");
 
-var _findQueryMark = require("../utils/find-query-mark");
+var _dom = require("../../../utils/dom");
 
-var _isQueryActive = require("../utils/is-query-active");
+var _reducer = require("./reducer");
 
-var _actions = require("./actions");
+var _decorations = require("./decorations");
 
-var _pluginKey = require("./plugin-key");
+var _utils = require("./utils");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+var hasTypeAheadStep = function hasTypeAheadStep(tr) {
+  var step = tr.steps.find(function (step) {
+    return step instanceof _steps.InsertTypeAheadStep;
+  });
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+  if (!step) {
+    return null;
+  }
 
-function createInitialPluginState() {
-  var prevActiveState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-  var isAllowed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  return {
-    isAllowed: isAllowed,
-    active: false,
-    prevActiveState: prevActiveState,
-    query: null,
-    trigger: null,
-    typeAheadHandler: null,
-    currentIndex: 0,
-    items: [],
-    itemsLoader: null,
-    queryMarkPos: null,
-    queryStarted: 0,
-    upKeyCount: 0,
-    downKeyCount: 0
-  };
-}
+  return step;
+};
 
-function createPlugin(dispatch, reactContext, typeAhead) {
+function createPlugin(_ref) {
+  var reactDispatch = _ref.reactDispatch,
+      reactContext = _ref.reactContext,
+      popupMountRef = _ref.popupMountRef,
+      createAnalyticsEvent = _ref.createAnalyticsEvent,
+      typeAheadHandlers = _ref.typeAheadHandlers;
+  var intl = reactContext().intl;
+
+  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 _prosemirrorState.Plugin({
-    key: _pluginKey.pluginKey,
+    key: _key.pluginKey,
     state: {
       init: function init() {
-        return createInitialPluginState();
+        return {
+          typeAheadHandlers: typeAheadHandlers,
+          query: '',
+          decorationSet: _prosemirrorView.DecorationSet.empty,
+          decorationElement: null,
+          items: [],
+          selectedIndex: 0,
+          stats: null,
+          inputMethod: null
+        };
       },
-      apply: function apply(tr, pluginState, _oldState, state) {
-        var meta = tr.getMeta(_pluginKey.pluginKey) || {};
-        var action = meta.action,
-            params = meta.params;
+      apply: function apply(tr, currentPluginState, oldEditorState, state) {
+        var customStep = hasTypeAheadStep(tr);
+        var nextPluginState = reducer(tr, currentPluginState, customStep);
 
-        switch (action) {
-          case _actions.ACTIONS.SET_CURRENT_INDEX:
-            return setCurrentItemIndex({
-              dispatch: dispatch,
-              pluginState: pluginState,
-              tr: tr,
-              params: params
-            });
-
-          case _actions.ACTIONS.SELECT_PREV:
-            return selectPrevActionHandler({
-              dispatch: dispatch,
-              pluginState: pluginState,
-              tr: tr
-            });
-
-          case _actions.ACTIONS.SELECT_NEXT:
-            return selectNextActionHandler({
-              dispatch: dispatch,
-              pluginState: pluginState,
-              tr: tr
-            });
-
-          case _actions.ACTIONS.ITEMS_LIST_UPDATED:
-            return itemsListUpdatedActionHandler({
-              dispatch: dispatch,
-              pluginState: pluginState,
-              tr: tr
-            });
-
-          case _actions.ACTIONS.SELECT_CURRENT:
-            var _tr$selection = tr.selection,
-                from = _tr$selection.from,
-                to = _tr$selection.to;
-            var typeAheadQuery = state.schema.marks.typeAheadQuery; // If inserted content has typeAheadQuery mark should fallback to default action handler
+        if (currentPluginState !== nextPluginState) {
+          reactDispatch(_key.pluginKey, nextPluginState);
+        }
 
-            return tr.doc.rangeHasMark(from - 1, to, typeAheadQuery) ? defaultActionHandler({
-              dispatch: dispatch,
-              reactContext: reactContext,
-              typeAhead: typeAhead,
-              state: state,
-              pluginState: pluginState,
-              tr: tr
-            }) : selectCurrentActionHandler({
-              dispatch: dispatch,
-              pluginState: pluginState,
-              tr: tr
-            });
+        return nextPluginState;
+      }
+    },
+    appendTransaction: function appendTransaction(transactions, _oldState, newState) {
+      var insertItemCallback = (0, _utils.isInsertionTransaction)(transactions, _actions.ACTIONS.INSERT_RAW_QUERY);
 
-          case _actions.ACTIONS.SET_QUERY:
-            return updateQueryHandler({
-              dispatch: dispatch,
-              pluginState: pluginState,
-              tr: tr,
-              params: params
-            });
+      if (insertItemCallback) {
+        var tr = insertItemCallback(newState);
 
-          default:
-            return defaultActionHandler({
-              dispatch: dispatch,
-              reactContext: reactContext,
-              typeAhead: typeAhead,
-              state: state,
-              pluginState: pluginState,
-              tr: tr
-            });
+        if (tr) {
+          return tr;
         }
       }
     },
     view: function view() {
       return {
-        update: function update(editorView) {
-          var pluginState = _pluginKey.pluginKey.getState(editorView.state);
-
-          if (!pluginState) {
-            return;
-          }
-
-          var state = editorView.state,
-              dispatch = editorView.dispatch;
-          var doc = state.doc,
-              selection = state.selection;
-          var from = selection.from,
-              to = selection.to;
-          var typeAheadQuery = state.schema.marks.typeAheadQuery; // Disable type ahead query when removing trigger.
-
-          if (pluginState.active && !pluginState.query && !pluginState.trigger) {
-            (0, _dismiss.dismissCommand)()(state, dispatch);
-            return;
-          } // Disable type ahead query when the first character is a space.
-
-
-          if (pluginState.active && (pluginState.query || '').indexOf(' ') === 0) {
-            (0, _dismiss.dismissCommand)()(state, dispatch);
-            return;
-          } // Optimization to not call dismissCommand if plugin is in an inactive state.
-
-
-          if (!pluginState.active && pluginState.prevActiveState && !doc.rangeHasMark(from - 1, to, typeAheadQuery)) {
-            (0, _dismiss.dismissCommand)()(state, dispatch);
-            return;
-          } // Fetch type ahead items if handler returned a promise.
-
-
-          if (pluginState.active && pluginState.itemsLoader) {
-            pluginState.itemsLoader.promise.then(function (items) {
-              return (0, _itemsListUpdated.itemsListUpdated)(items)(editorView.state, dispatch);
-            });
-          }
-        }
+        update: function update(editorView) {}
       };
     },
-    appendTransaction: function appendTransaction(_trs, _oldState, newState) {
-      var pluginState = _pluginKey.pluginKey.getState(newState);
-
-      if (pluginState.active && pluginState.query && pluginState.typeAheadHandler && pluginState.typeAheadHandler.forceSelect) {
-        var items = pluginState.items;
-        var matchedItem = pluginState.typeAheadHandler.forceSelect(pluginState.query, items);
-
-        if (matchedItem) {
-          var newTr;
-          (0, _selectItem.selectByIndex)(items.indexOf(matchedItem))(newState, function (tr) {
-            return newTr = tr;
-          });
-          return newTr;
-        }
-      }
-
-      return null;
-    },
     props: {
-      handleDOMEvents: {
-        input: function input(view, event) {
-          var state = view.state,
-              dispatch = view.dispatch;
-          var selection = state.selection,
-              schema = state.schema;
-
-          if (selection instanceof _prosemirrorState.TextSelection && selection.$cursor && schema.marks.typeAheadQuery.isInSet(selection.$cursor.marks())) {
-            (0, _updateQuery.updateQueryCommand)(event.data)(state, dispatch);
-            return false;
-          }
+      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;
         },
-        // FM-2123: On latest Android version Q there's a bug while compositionend,
-        // the typeAheadQuery is inserted next to the position of the trigger character (so that creates double characters).
-        // In this use case, need to replace the last written character with our typeAheadQuery.
-        compositionend: function compositionend(view, event) {
-          var state = view.state,
-              dispatch = view.dispatch;
-          var selection = state.selection,
-              schema = state.schema;
-          var triggers = typeAhead.map(function (typeAheadHandler) {
-            return typeAheadHandler.trigger;
-          });
+        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 (triggers.indexOf(event.data) !== -1 && selection instanceof _prosemirrorState.TextSelection && selection.$cursor && !schema.marks.typeAheadQuery.isInSet(selection.$cursor.marks())) {
-            (0, _insertQuery.insertTypeAheadQuery)(event.data, true)(state, dispatch);
+          if (target instanceof HTMLElement && (0, _dom.closest)(target, "[data-type-ahead=".concat(_constants.TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE, "]"))) {
             return true;
           }
 
@@ -255,220 +126,4 @@ function createPlugin(dispatch, reactContext, typeAhead) {
       }
     }
   });
-}
-/**
- *
- * Action Handlers
- *
- */
-
-
-function createItemsLoader(promiseOfItems) {
-  var canceled = false;
-  return {
-    promise: new Promise(function (resolve, reject) {
-      promiseOfItems.then(function (result) {
-        return !canceled && resolve(result);
-      }).catch(function (error) {
-        return !canceled && reject(error);
-      });
-    }),
-    cancel: function cancel() {
-      canceled = true;
-    }
-  };
-}
-
-function defaultActionHandler(_ref) {
-  var dispatch = _ref.dispatch,
-      reactContext = _ref.reactContext,
-      typeAhead = _ref.typeAhead,
-      pluginState = _ref.pluginState,
-      state = _ref.state,
-      tr = _ref.tr;
-  var typeAheadQuery = state.schema.marks.typeAheadQuery;
-  var doc = state.doc,
-      selection = state.selection;
-  var from = selection.from,
-      to = selection.to;
-  var isActive = (0, _isQueryActive.isQueryActive)(typeAheadQuery, doc, from - 1, to);
-  var isAllowed = (0, _utils.isMarkTypeAllowedInCurrentSelection)(typeAheadQuery, state);
-
-  if (!isAllowed && !isActive) {
-    if (pluginState && pluginState.active === isActive && pluginState.isAllowed === isAllowed) {
-      return pluginState;
-    }
-
-    var _newPluginState = createInitialPluginState(pluginState.active, isAllowed);
-
-    dispatch(_pluginKey.pluginKey, _newPluginState);
-    return _newPluginState;
-  }
-
-  var nodeBefore = selection.$from.nodeBefore;
-
-  if (!isActive || !nodeBefore || !pluginState) {
-    var _newPluginState2 = createInitialPluginState(pluginState ? pluginState.active : false);
-
-    if (!pluginState || pluginState.active || !pluginState.isAllowed) {
-      dispatch(_pluginKey.pluginKey, _newPluginState2);
-    }
-
-    return _newPluginState2;
-  }
-
-  var typeAheadMark = typeAheadQuery.isInSet(nodeBefore.marks || []);
-
-  if (!typeAheadMark || !typeAheadMark.attrs.trigger) {
-    return pluginState;
-  }
-
-  var textContent = nodeBefore.textContent || '';
-  var trigger = typeAheadMark.attrs.trigger.replace(/([^\x00-\xFF]|[\s\n])+/g, ''); // If trigger has been removed, reset plugin state
-
-  if (!textContent.includes(trigger)) {
-    var _newPluginState3 = _objectSpread(_objectSpread({}, createInitialPluginState(true)), {}, {
-      active: true
-    });
-
-    dispatch(_pluginKey.pluginKey, _newPluginState3);
-    return _newPluginState3;
-  }
-
-  var query = textContent.replace(/^([^\x00-\xFF]|[\s\n])+/g, '').replace(trigger, '');
-  var typeAheadHandler = typeAhead.find(function (t) {
-    return t.trigger === trigger;
-  });
-  var typeAheadItems = [];
-  var itemsLoader = null;
-  var highlight = null;
-
-  try {
-    var _reactContext = reactContext(),
-        intl = _reactContext.intl;
-
-    typeAheadItems = typeAheadHandler.getItems(query, state, intl, {
-      prevActive: pluginState.prevActiveState,
-      queryChanged: query !== pluginState.query || trigger !== pluginState.trigger
-    }, tr, dispatch);
-
-    if (typeAheadHandler.getHighlight) {
-      highlight = typeAheadHandler.getHighlight(state);
-    }
-
-    if (pluginState.itemsLoader) {
-      pluginState.itemsLoader.cancel();
-    }
-
-    if (!Array.isArray(typeAheadItems)) {
-      itemsLoader = createItemsLoader(typeAheadItems);
-      typeAheadItems = pluginState.items;
-    }
-  } catch (e) {}
-
-  var queryMark = (0, _findQueryMark.findTypeAheadQuery)(state);
-  var newPluginState = {
-    isAllowed: isAllowed,
-    query: query,
-    trigger: trigger,
-    typeAheadHandler: typeAheadHandler,
-    active: true,
-    prevActiveState: pluginState.active,
-    items: typeAheadItems,
-    itemsLoader: itemsLoader,
-    currentIndex: pluginState.currentIndex,
-    queryMarkPos: queryMark !== null ? queryMark.start : null,
-    queryStarted: Date.now(),
-    upKeyCount: 0,
-    downKeyCount: 0,
-    highlight: highlight
-  };
-  dispatch(_pluginKey.pluginKey, newPluginState);
-  return newPluginState;
-}
-
-function setCurrentItemIndex(_ref2) {
-  var dispatch = _ref2.dispatch,
-      pluginState = _ref2.pluginState,
-      params = _ref2.params;
-
-  if (!params) {
-    return pluginState;
-  }
-
-  var newPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
-    currentIndex: params.currentIndex || params.currentIndex === 0 ? params.currentIndex : pluginState.currentIndex
-  });
-
-  dispatch(_pluginKey.pluginKey, newPluginState);
-  return newPluginState;
-}
-
-function updateQueryHandler(_ref3) {
-  var dispatch = _ref3.dispatch,
-      pluginState = _ref3.pluginState,
-      params = _ref3.params;
-
-  if (!params) {
-    return pluginState;
-  }
-
-  var newPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
-    query: typeof params.query === 'string' ? params.query : null
-  });
-
-  dispatch(_pluginKey.pluginKey, newPluginState);
-  return newPluginState;
-}
-
-function selectPrevActionHandler(_ref4) {
-  var dispatch = _ref4.dispatch,
-      pluginState = _ref4.pluginState;
-  var newIndex = pluginState.currentIndex - 1;
-
-  var newPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
-    currentIndex: newIndex < 0 ? pluginState.items.length - 1 : newIndex,
-    upKeyCount: ++pluginState.upKeyCount
-  });
-
-  dispatch(_pluginKey.pluginKey, newPluginState);
-  return newPluginState;
-}
-
-function selectNextActionHandler(_ref5) {
-  var dispatch = _ref5.dispatch,
-      pluginState = _ref5.pluginState;
-  var newIndex = pluginState.currentIndex + 1;
-
-  var newPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
-    currentIndex: newIndex > pluginState.items.length - 1 ? 0 : newIndex,
-    downKeyCount: ++pluginState.downKeyCount
-  });
-
-  dispatch(_pluginKey.pluginKey, newPluginState);
-  return newPluginState;
-}
-
-function itemsListUpdatedActionHandler(_ref6) {
-  var dispatch = _ref6.dispatch,
-      pluginState = _ref6.pluginState,
-      tr = _ref6.tr;
-  var items = tr.getMeta(_pluginKey.pluginKey).items;
-
-  var newPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
-    items: items,
-    itemsLoader: null,
-    // Set to 0 to always reset the query to the top of the typeahead
-    currentIndex: 0
-  });
-
-  dispatch(_pluginKey.pluginKey, newPluginState);
-  return newPluginState;
-}
-
-function selectCurrentActionHandler(_ref7) {
-  var dispatch = _ref7.dispatch;
-  var newPluginState = createInitialPluginState(false);
-  dispatch(_pluginKey.pluginKey, newPluginState);
-  return newPluginState;
 }