@atlaskit/editor-plugin-find-replace 0.1.0

package/dist/es2019/FindReplaceToolbarButtonWithState.js

@@ -0,0 +1,153 @@
+import React, { useLayoutEffect, useState } from 'react';
+import { TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
+import { blur, toggleMatchCase } from './commands';
+import { activateWithAnalytics, cancelSearchWithAnalytics, findNextWithAnalytics, findPrevWithAnalytics, findWithAnalytics, replaceAllWithAnalytics, replaceWithAnalytics } from './commands-with-analytics';
+import FindReplaceToolbarButton from './ui/FindReplaceToolbarButton';
+
+// light implementation of useSharedPluginState(). This is due to findreplace
+// being the only plugin that previously used WithPluginState with
+// debounce=false. That was implemented because of text sync issues
+// between editor & findreplace dialog.
+// To address under ENGHEALTH-5853
+const useSharedPluginStateNoDebounce = api => {
+  const [state, setState] = useState(api === null || api === void 0 ? void 0 : api.findReplace.sharedState.currentState());
+  useLayoutEffect(() => {
+    const unsub = api === null || api === void 0 ? void 0 : api.findReplace.sharedState.onChange(({
+      nextSharedState
+    }) => {
+      setState(nextSharedState);
+    });
+    return () => {
+      unsub === null || unsub === void 0 ? void 0 : unsub();
+    };
+  }, [api]);
+  return {
+    findReplaceState: state
+  };
+};
+const FindReplaceToolbarButtonWithState = ({
+  popupsBoundariesElement,
+  popupsMountPoint,
+  popupsScrollableElement,
+  isToolbarReducedSpacing,
+  editorView,
+  containerElement,
+  dispatchAnalyticsEvent,
+  featureFlags,
+  takeFullWidth,
+  api
+}) => {
+  var _api$analytics;
+  const editorAnalyticsAPI = api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions;
+  const {
+    findReplaceState
+  } = useSharedPluginStateNoDebounce(api);
+  if (!editorView) {
+    return null;
+  }
+
+  // we need the editor to be in focus for scrollIntoView() to work
+  // so we focus it while we run the command, then put focus back into
+  // whatever element was previously focused in find replace component
+  const runWithEditorFocused = fn => {
+    const activeElement = document.activeElement;
+    editorView.focus();
+    fn();
+    activeElement === null || activeElement === void 0 ? void 0 : activeElement.focus();
+  };
+  const dispatchCommand = cmd => {
+    const {
+      state,
+      dispatch
+    } = editorView;
+    cmd(state, dispatch);
+  };
+  const handleActivate = () => {
+    runWithEditorFocused(() => dispatchCommand(activateWithAnalytics(editorAnalyticsAPI)({
+      triggerMethod: TRIGGER_METHOD.TOOLBAR
+    })));
+  };
+  const handleFind = keyword => {
+    runWithEditorFocused(() => dispatchCommand(findWithAnalytics(editorAnalyticsAPI)({
+      editorView,
+      containerElement,
+      keyword
+    })));
+  };
+  const handleFindNext = ({
+    triggerMethod
+  }) => {
+    runWithEditorFocused(() => dispatchCommand(findNextWithAnalytics(editorAnalyticsAPI)({
+      triggerMethod
+    })));
+  };
+  const handleFindPrev = ({
+    triggerMethod
+  }) => {
+    runWithEditorFocused(() => dispatchCommand(findPrevWithAnalytics(editorAnalyticsAPI)({
+      triggerMethod
+    })));
+  };
+  const handleReplace = ({
+    triggerMethod,
+    replaceText
+  }) => {
+    runWithEditorFocused(() => dispatchCommand(replaceWithAnalytics(editorAnalyticsAPI)({
+      triggerMethod,
+      replaceText
+    })));
+  };
+  const handleReplaceAll = ({
+    replaceText
+  }) => {
+    runWithEditorFocused(() => dispatchCommand(replaceAllWithAnalytics(editorAnalyticsAPI)({
+      replaceText
+    })));
+  };
+  const handleFindBlur = () => {
+    dispatchCommand(blur());
+  };
+  const handleCancel = ({
+    triggerMethod
+  }) => {
+    dispatchCommand(cancelSearchWithAnalytics(editorAnalyticsAPI)({
+      triggerMethod
+    }));
+    editorView.focus();
+  };
+  const handleToggleMatchCase = () => {
+    dispatchCommand(toggleMatchCase());
+  };
+  const {
+    findReplaceMatchCase
+  } = featureFlags;
+  if (!findReplaceState) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(FindReplaceToolbarButton, {
+    allowMatchCase: findReplaceMatchCase,
+    shouldMatchCase: findReplaceState.shouldMatchCase,
+    onToggleMatchCase: handleToggleMatchCase,
+    isActive: findReplaceState.isActive,
+    findText: findReplaceState.findText,
+    index: findReplaceState.index,
+    numMatches: findReplaceState.matches.length,
+    replaceText: findReplaceState.replaceText,
+    shouldFocus: findReplaceState.shouldFocus,
+    popupsBoundariesElement: popupsBoundariesElement,
+    popupsMountPoint: popupsMountPoint,
+    popupsScrollableElement: popupsScrollableElement,
+    isReducedSpacing: !!isToolbarReducedSpacing,
+    dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+    onFindBlur: handleFindBlur,
+    onCancel: handleCancel,
+    onActivate: handleActivate,
+    onFind: handleFind,
+    onFindNext: handleFindNext,
+    onFindPrev: handleFindPrev,
+    onReplace: handleReplace,
+    onReplaceAll: handleReplaceAll,
+    takeFullWidth: !!takeFullWidth
+  });
+};
+export default /*#__PURE__*/React.memo(FindReplaceToolbarButtonWithState);

package/dist/es2019/actions.js

@@ -0,0 +1,13 @@
+export let FindReplaceActionTypes = /*#__PURE__*/function (FindReplaceActionTypes) {
+  FindReplaceActionTypes["ACTIVATE"] = "ACTIVATE";
+  FindReplaceActionTypes["FIND"] = "FIND";
+  FindReplaceActionTypes["UPDATE_DECORATIONS"] = "UPDATE_DECORATIONS";
+  FindReplaceActionTypes["FIND_NEXT"] = "FIND_NEXT";
+  FindReplaceActionTypes["FIND_PREVIOUS"] = "FIND_PREVIOUS";
+  FindReplaceActionTypes["REPLACE"] = "REPLACE";
+  FindReplaceActionTypes["REPLACE_ALL"] = "REPLACE_ALL";
+  FindReplaceActionTypes["CANCEL"] = "CANCEL";
+  FindReplaceActionTypes["BLUR"] = "BLUR";
+  FindReplaceActionTypes["TOGGLE_MATCH_CASE"] = "TOGGLE_MATCH_CASE";
+  return FindReplaceActionTypes;
+}({});

package/dist/es2019/commands-with-analytics.js

@@ -0,0 +1,72 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { withAnalytics } from '@atlaskit/editor-common/editor-analytics';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { activate, cancelSearch, find, findNext, findPrevious, replace, replaceAll } from './commands';
+export const activateWithAnalytics = editorAnalyticsAPI => ({
+  triggerMethod
+}) => withAnalytics(editorAnalyticsAPI, state => ({
+  eventType: EVENT_TYPE.UI,
+  action: ACTION.ACTIVATED,
+  actionSubject: ACTION_SUBJECT.FIND_REPLACE_DIALOG,
+  attributes: {
+    inputMethod: state.selection instanceof TextSelection && !state.selection.empty ? INPUT_METHOD.PREFILL : INPUT_METHOD.KEYBOARD,
+    triggerMethod
+  }
+}))(activate());
+export const findWithAnalytics = editorAnalyticsAPI => ({
+  editorView,
+  containerElement,
+  keyword
+}) => withAnalytics(editorAnalyticsAPI, {
+  eventType: EVENT_TYPE.TRACK,
+  action: ACTION.FIND_PERFORMED,
+  actionSubject: ACTION_SUBJECT.TEXT
+})(find(editorView, containerElement, keyword));
+export const findNextWithAnalytics = editorAnalyticsAPI => ({
+  triggerMethod
+}) => withAnalytics(editorAnalyticsAPI, {
+  eventType: EVENT_TYPE.TRACK,
+  action: ACTION.FIND_NEXT_PERFORMED,
+  actionSubject: ACTION_SUBJECT.TEXT,
+  attributes: {
+    triggerMethod
+  }
+})(findNext());
+export const findPrevWithAnalytics = editorAnalyticsAPI => ({
+  triggerMethod
+}) => withAnalytics(editorAnalyticsAPI, {
+  eventType: EVENT_TYPE.TRACK,
+  action: ACTION.FIND_PREV_PERFORMED,
+  actionSubject: ACTION_SUBJECT.TEXT,
+  attributes: {
+    triggerMethod
+  }
+})(findPrevious());
+export const replaceWithAnalytics = editorAnalyticsAPI => ({
+  triggerMethod,
+  replaceText
+}) => withAnalytics(editorAnalyticsAPI, {
+  eventType: EVENT_TYPE.TRACK,
+  action: ACTION.REPLACED_ONE,
+  actionSubject: ACTION_SUBJECT.TEXT,
+  attributes: {
+    triggerMethod
+  }
+})(replace(replaceText));
+export const replaceAllWithAnalytics = editorAnalyticsAPI => ({
+  replaceText
+}) => withAnalytics(editorAnalyticsAPI, {
+  eventType: EVENT_TYPE.TRACK,
+  action: ACTION.REPLACED_ALL,
+  actionSubject: ACTION_SUBJECT.TEXT
+})(replaceAll(replaceText));
+export const cancelSearchWithAnalytics = editorAnalyticsAPI => ({
+  triggerMethod
+}) => withAnalytics(editorAnalyticsAPI, {
+  eventType: EVENT_TYPE.UI,
+  action: ACTION.DEACTIVATED,
+  actionSubject: ACTION_SUBJECT.FIND_REPLACE_DIALOG,
+  attributes: {
+    triggerMethod
+  }
+})(cancelSearch());

package/dist/es2019/commands.js

@@ -0,0 +1,240 @@
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { FindReplaceActionTypes } from './actions';
+import { createCommand, getPluginState } from './pm-plugins/plugin-factory';
+import { createDecoration, findDecorationFromMatch, findMatches, findSearchIndex, getSelectedText, getSelectionForMatch, nextIndex, prevIndex, removeDecorationsFromSet, removeMatchesFromSet } from './utils';
+import batchDecorations from './utils/batch-decorations';
+import { withScrollIntoView } from './utils/commands';
+export const activate = () => createCommand(state => {
+  const {
+    selection
+  } = state;
+  let findText;
+  let matches;
+  let index;
+
+  // if user has selected text and hit cmd-f, set that as the keyword
+  if (selection instanceof TextSelection && !selection.empty) {
+    findText = getSelectedText(selection);
+    const {
+      shouldMatchCase
+    } = getPluginState(state);
+    matches = findMatches(state.doc, findText, shouldMatchCase);
+    index = findSearchIndex(selection.from, matches);
+  }
+  return {
+    type: FindReplaceActionTypes.ACTIVATE,
+    findText,
+    matches,
+    index
+  };
+});
+export const find = (editorView, containerElement, keyword) => withScrollIntoView(createCommand(state => {
+  const {
+    selection
+  } = state;
+  const {
+    shouldMatchCase
+  } = getPluginState(state);
+  const matches = keyword !== undefined ? findMatches(state.doc, keyword, shouldMatchCase) : [];
+  const index = findSearchIndex(selection.from, matches);
+
+  // we can't just apply all the decorations to highlight the search results at once
+  // as if there are a lot ProseMirror cries :'(
+  batchDecorations.applyAllSearchDecorations(editorView, containerElement, decorations => addDecorations(decorations)(editorView.state, editorView.dispatch), decorations => removeDecorations(decorations)(editorView.state, editorView.dispatch));
+  return {
+    type: FindReplaceActionTypes.FIND,
+    findText: keyword || '',
+    matches,
+    index
+  };
+}, (tr, state) => {
+  const {
+    selection
+  } = state;
+  const {
+    shouldMatchCase
+  } = getPluginState(state);
+  const matches = keyword !== undefined ? findMatches(state.doc, keyword, shouldMatchCase) : [];
+  if (matches.length > 0) {
+    const index = findSearchIndex(selection.from, matches);
+    return tr.setSelection(getSelectionForMatch(tr.selection, tr.doc, index, matches));
+  }
+  return tr;
+}));
+export const findNext = () => withScrollIntoView(createCommand(state => findInDirection(state, 'next'), (tr, state) => {
+  const {
+    matches,
+    index
+  } = getPluginState(state);
+  // can't use index from plugin state because if the cursor has moved, it will still be the
+  // OLD index (the find next operation should look for the first match forward starting
+  // from the current cursor position)
+  let searchIndex = findSearchIndex(state.selection.from, matches);
+  if (searchIndex === index) {
+    // cursor has not moved, so we just want to find the next in matches array
+    searchIndex = nextIndex(searchIndex, matches.length);
+  }
+  return tr.setSelection(getSelectionForMatch(tr.selection, tr.doc, searchIndex, matches));
+}));
+export const findPrevious = () => withScrollIntoView(createCommand(state => findInDirection(state, 'previous'), (tr, state) => {
+  const {
+    matches
+  } = getPluginState(state);
+  // can't use index from plugin state because if the cursor has moved, it will still be the
+  // OLD index (the find prev operation should look for the first match backward starting
+  // from the current cursor position)
+  const searchIndex = findSearchIndex(state.selection.from, matches, true);
+  return tr.setSelection(getSelectionForMatch(tr.selection, tr.doc, searchIndex, matches));
+}));
+const findInDirection = (state, dir) => {
+  const pluginState = getPluginState(state);
+  const {
+    matches,
+    findText
+  } = pluginState;
+  let {
+    decorationSet,
+    index
+  } = pluginState;
+  if (findText) {
+    const searchIndex = findSearchIndex(state.selection.from, matches, dir === 'previous');
+    // compare index from plugin state and index of first match forward from cursor position
+    if (index === searchIndex) {
+      // normal case, cycling through matches
+      index = dir === 'next' ? nextIndex(index, matches.length) : prevIndex(index, matches.length);
+    } else {
+      // cursor has moved
+      index = searchIndex;
+    }
+    decorationSet = updateSelectedHighlight(state, index);
+  }
+  return {
+    type: dir === 'next' ? FindReplaceActionTypes.FIND_NEXT : FindReplaceActionTypes.FIND_PREVIOUS,
+    index,
+    decorationSet
+  };
+};
+export const replace = replaceText => withScrollIntoView(createCommand(state => {
+  const pluginState = getPluginState(state);
+  const {
+    findText
+  } = pluginState;
+  let {
+    decorationSet,
+    matches,
+    index
+  } = pluginState;
+  decorationSet = updateSelectedHighlight(state, nextIndex(index, matches.length));
+  if (replaceText.toLowerCase().indexOf(findText.toLowerCase()) === -1) {
+    decorationSet = removeMatchesFromSet(decorationSet, [matches[index]], state.doc);
+    matches.splice(index, 1);
+    if (index > matches.length - 1) {
+      index = 0;
+    }
+  } else {
+    index = nextIndex(index, matches.length);
+  }
+  return {
+    type: FindReplaceActionTypes.REPLACE,
+    replaceText,
+    decorationSet,
+    matches,
+    index
+  };
+}, (tr, state) => {
+  const {
+    matches,
+    index,
+    findText
+  } = getPluginState(state);
+  if (matches[index]) {
+    const {
+      start,
+      end
+    } = matches[index];
+    const newIndex = nextIndex(index, matches.length);
+    tr.insertText(replaceText, start, end).setSelection(getSelectionForMatch(tr.selection, tr.doc, newIndex, matches, newIndex === 0 ? 0 : replaceText.length - findText.length));
+  }
+  return tr;
+}));
+export const replaceAll = replaceText => createCommand({
+  type: FindReplaceActionTypes.REPLACE_ALL,
+  replaceText: replaceText,
+  decorationSet: DecorationSet.empty,
+  matches: [],
+  index: 0
+}, (tr, state) => {
+  const pluginState = getPluginState(state);
+  pluginState.matches.forEach(match => {
+    tr.insertText(replaceText, tr.mapping.map(match.start), tr.mapping.map(match.end));
+  });
+  tr.setMeta('scrollIntoView', false);
+  return tr;
+});
+export const addDecorations = decorations => createCommand(state => {
+  const {
+    decorationSet
+  } = getPluginState(state);
+  return {
+    type: FindReplaceActionTypes.UPDATE_DECORATIONS,
+    decorationSet: decorationSet.add(state.doc, decorations)
+  };
+});
+export const removeDecorations = decorations => createCommand(state => {
+  const {
+    decorationSet
+  } = getPluginState(state);
+  return {
+    type: FindReplaceActionTypes.UPDATE_DECORATIONS,
+    decorationSet: removeDecorationsFromSet(decorationSet, decorations, state.doc)
+  };
+});
+export const cancelSearch = () => createCommand(() => {
+  batchDecorations.stop();
+  return {
+    type: FindReplaceActionTypes.CANCEL
+  };
+});
+export const blur = () => createCommand({
+  type: FindReplaceActionTypes.BLUR
+});
+export const toggleMatchCase = () => createCommand({
+  type: FindReplaceActionTypes.TOGGLE_MATCH_CASE
+});
+const updateSelectedHighlight = (state, nextSelectedIndex) => {
+  let {
+    decorationSet,
+    index,
+    matches
+  } = getPluginState(state);
+  const currentSelectedMatch = matches[index];
+  const nextSelectedMatch = matches[nextSelectedIndex];
+  if (index === nextSelectedIndex) {
+    return decorationSet;
+  }
+  const currentSelectedDecoration = findDecorationFromMatch(decorationSet, currentSelectedMatch);
+  const nextSelectedDecoration = findDecorationFromMatch(decorationSet, nextSelectedMatch);
+
+  // Update decorations so the current selected match becomes a normal match
+  // and the next selected gets the selected styling
+  const decorationsToRemove = [];
+  if (currentSelectedDecoration) {
+    decorationsToRemove.push(currentSelectedDecoration);
+  }
+  if (nextSelectedDecoration) {
+    decorationsToRemove.push(nextSelectedDecoration);
+  }
+  if (decorationsToRemove.length > 0) {
+    // removeDecorationsFromSet depends on decorations being pre-sorted
+    decorationsToRemove.sort((a, b) => a.from < b.from ? -1 : 1);
+    decorationSet = removeDecorationsFromSet(decorationSet, decorationsToRemove, state.doc);
+  }
+  if (currentSelectedMatch) {
+    decorationSet = decorationSet.add(state.doc, [createDecoration(currentSelectedMatch.start, currentSelectedMatch.end)]);
+  }
+  if (nextSelectedMatch) {
+    decorationSet = decorationSet.add(state.doc, [createDecoration(nextSelectedMatch.start, nextSelectedMatch.end, true)]);
+  }
+  return decorationSet;
+};

package/dist/es2019/index.js

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

package/dist/es2019/plugin.js

@@ -0,0 +1,88 @@
+import React from 'react';
+import FindReplaceToolbarButtonWithState from './FindReplaceToolbarButtonWithState';
+import keymapPlugin from './pm-plugins/keymap';
+import { createPlugin } from './pm-plugins/main';
+import { findReplacePluginKey } from './pm-plugins/plugin-key';
+export const findReplacePlugin = ({
+  config: props,
+  api
+}) => {
+  var _api$featureFlags;
+  const featureFlags = (api === null || api === void 0 ? void 0 : (_api$featureFlags = api.featureFlags) === null || _api$featureFlags === void 0 ? void 0 : _api$featureFlags.sharedState.currentState()) || {};
+  return {
+    name: 'findReplace',
+    pmPlugins() {
+      return [{
+        name: 'findReplace',
+        plugin: ({
+          dispatch
+        }) => createPlugin(dispatch)
+      }, {
+        name: 'findReplaceKeymap',
+        plugin: () => {
+          var _api$analytics;
+          return keymapPlugin(api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions);
+        }
+      }];
+    },
+    getSharedState(editorState) {
+      if (!editorState) {
+        return undefined;
+      }
+      return findReplacePluginKey.getState(editorState) || undefined;
+    },
+    actions: {
+      getToolbarButton: ({
+        popupsBoundariesElement,
+        popupsMountPoint,
+        popupsScrollableElement,
+        editorView,
+        containerElement,
+        dispatchAnalyticsEvent,
+        isToolbarReducedSpacing
+      }) => {
+        return /*#__PURE__*/React.createElement(FindReplaceToolbarButtonWithState, {
+          popupsBoundariesElement: popupsBoundariesElement,
+          popupsMountPoint: popupsMountPoint,
+          popupsScrollableElement: popupsScrollableElement,
+          editorView: editorView,
+          containerElement: containerElement,
+          dispatchAnalyticsEvent: dispatchAnalyticsEvent
+          // `allowMatchCase` comes through the preset, but not the feature flags
+          // prop with the `ComposableEditor` - grab the FFs from the editor API
+          // instead until we clean this up.
+          ,
+          featureFlags: featureFlags,
+          isToolbarReducedSpacing: isToolbarReducedSpacing,
+          api: api
+        });
+      }
+    },
+    primaryToolbarComponent({
+      popupsBoundariesElement,
+      popupsMountPoint,
+      popupsScrollableElement,
+      isToolbarReducedSpacing,
+      editorView,
+      containerElement,
+      dispatchAnalyticsEvent
+    }) {
+      if (props !== null && props !== void 0 && props.twoLineEditorToolbar) {
+        return null;
+      } else {
+        return /*#__PURE__*/React.createElement(FindReplaceToolbarButtonWithState, {
+          popupsBoundariesElement: popupsBoundariesElement,
+          popupsMountPoint: popupsMountPoint,
+          popupsScrollableElement: popupsScrollableElement,
+          isToolbarReducedSpacing: isToolbarReducedSpacing,
+          editorView: editorView,
+          containerElement: containerElement,
+          dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+          takeFullWidth: props === null || props === void 0 ? void 0 : props.takeFullWidth,
+          featureFlags: featureFlags,
+          api: api
+        });
+      }
+    }
+  };
+};

package/dist/es2019/pm-plugins/keymap.js

@@ -0,0 +1,16 @@
+import { TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
+import { bindKeymapWithCommand, find as findKeymap } from '@atlaskit/editor-common/keymaps';
+import { keymap } from '@atlaskit/editor-prosemirror/keymap';
+import { activateWithAnalytics } from '../commands-with-analytics';
+const activateFindReplace = editorAnalyticsAPI => (state, dispatch) => {
+  activateWithAnalytics(editorAnalyticsAPI)({
+    triggerMethod: TRIGGER_METHOD.SHORTCUT
+  })(state, dispatch);
+  return true;
+};
+const keymapPlugin = editorAnalyticsAPI => {
+  const list = {};
+  bindKeymapWithCommand(findKeymap.common, activateFindReplace(editorAnalyticsAPI), list);
+  return keymap(list);
+};
+export default keymapPlugin;

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

@@ -0,0 +1,30 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { createPluginState, getPluginState } from './plugin-factory';
+import { findReplacePluginKey } from './plugin-key';
+export const initialState = {
+  isActive: false,
+  shouldFocus: false,
+  findText: '',
+  replaceText: '',
+  index: 0,
+  matches: [],
+  decorationSet: DecorationSet.empty,
+  shouldMatchCase: false
+};
+export const createPlugin = dispatch => new SafePlugin({
+  key: findReplacePluginKey,
+  state: createPluginState(dispatch, () => initialState),
+  props: {
+    decorations(state) {
+      const {
+        isActive,
+        findText,
+        decorationSet
+      } = getPluginState(state);
+      if (isActive && findText) {
+        return decorationSet;
+      }
+    }
+  }
+});