@atlaskit/editor-core 191.0.8 → 191.0.9

package/dist/es2019/plugins/find-replace/ui/styles.js

@@ -1,48 +0,0 @@
-/** @jsx jsx */
-import { css } from '@emotion/react';
-import { N60, N30A } from '@atlaskit/theme/colors';
-import { relativeFontSizeToBase16 } from '@atlaskit/editor-shared-styles';
-export const replaceSectionButtonStyles = css({
-  marginLeft: "var(--ds-space-050, 4px)"
-});
-export const ruleStyles = css({
-  width: '100%',
-  border: 'none',
-  backgroundColor: `${`var(--ds-border, ${N30A})`}`,
-  margin: `${"var(--ds-space-050, 4px)"} 0px`,
-  height: '1px',
-  borderRadius: '1px'
-});
-export const wrapperStyles = css({
-  display: 'flex',
-  flexDirection: 'column',
-  '> *:not(#replace-hr-element)': {
-    margin: `0px ${"var(--ds-space-050, 4px)"}`
-  }
-});
-export const sectionWrapperStyles = css`
-  display: flex;
-
-  & > * {
-    display: inline-flex;
-    height: 32px;
-    flex: 0 0 auto;
-  }
-
-  & > [data-ds--text-field--container] {
-    display: flex;
-    flex: 1 1 auto;
-  }
-`;
-export const countStyles = css({
-  color: `${`var(--ds-text-subtlest, ${N60})`}`,
-  fontSize: `${relativeFontSizeToBase16(12)}`,
-  flex: '0 0 auto',
-  justifyContent: 'center',
-  alignItems: 'center',
-  marginLeft: "var(--ds-space-050, 4px)",
-  marginRight: "var(--ds-space-100, 8px)"
-});
-export const countWrapperStyles = css({
-  alignItems: 'center'
-});

package/dist/es2019/plugins/find-replace/utils/batch-decorations.js

@@ -1,189 +0,0 @@
-import { createDecorations, findDecorationFromMatch } from './index';
-import { getPluginState } from '../plugin';
-
-// max number of decorations to apply at once
-const batchIncrement = 100;
-// position range to apply decorations between before alternating above or below viewport
-const posIncrement = 2000;
-/**
- * Provides support for applying search match highlight decorations in batches
- */
-class BatchDecorations {
-  stop() {
-    if (this.rafId) {
-      cancelAnimationFrame(this.rafId);
-    }
-  }
-
-  /**
-   * Applies the decorations needed for the current search results
-   * It does so async, splitting them up into batches to help with performance
-   */
-  async applyAllSearchDecorations(editorView, containerElement, addDecorations, removeDecorations) {
-    this.stop();
-    this.addDecorations = addDecorations;
-    this.removeDecorations = removeDecorations;
-    if (!containerElement) {
-      return;
-    }
-    const pmElement = containerElement.querySelector('.ProseMirror');
-    if (!pmElement) {
-      return;
-    }
-    const positions = this.calcDecorationPositions(editorView, containerElement, pmElement);
-    const {
-      startPos,
-      endPos,
-      viewportStartPos,
-      viewportEndPos
-    } = positions;
-    let dir = 0;
-    let before = viewportStartPos;
-    let after = viewportEndPos - posIncrement;
-    await this.updateDecorationsBetween(editorView, viewportStartPos, viewportEndPos);
-    while (before > startPos || after < endPos) {
-      if (dir++ % 2 === 0 && before > startPos || after >= endPos) {
-        const diff = before - startPos;
-        before = Math.max(before - posIncrement, startPos);
-        await this.updateDecorationsBetween(editorView, before, before + Math.min(diff, posIncrement));
-      } else {
-        after = Math.min(after + posIncrement, endPos);
-        await this.updateDecorationsBetween(editorView, after, Math.min(after + posIncrement, endPos));
-      }
-    }
-  }
-  async updateDecorationsBetween(editorView, startPos, endPos) {
-    await this.removeDecorationsBetween(editorView, startPos, endPos);
-    await this.addDecorationsBetween(editorView, startPos, endPos);
-  }
-  async addDecorationsBetween(editorView, startPos, endPos) {
-    const {
-      selection
-    } = editorView.state;
-    const {
-      matches,
-      decorationSet
-    } = getPluginState(editorView.state);
-    if (matches.length === 0) {
-      return;
-    }
-    const matchesBetween = matches.filter(m => m.start >= startPos && (endPos === undefined || m.start < endPos));
-    const selectionMatch = matches.find(match => match.start >= selection.from);
-    const selectionIndex = matchesBetween.findIndex(match => match === selectionMatch);
-    return await this.batchRequests(counter => {
-      let matchesToDecorate = matchesBetween.slice(counter, counter + batchIncrement);
-      if (matchesToDecorate.length === 0) {
-        return false;
-      }
-      let useSelectionIndex = selectionIndex >= counter && selectionIndex < counter + batchIncrement;
-      if (selectionMatch && useSelectionIndex) {
-        const selectionMatchDecoration = findDecorationFromMatch(decorationSet, selectionMatch);
-        if (selectionMatchDecoration) {
-          matchesToDecorate.splice(selectionIndex % batchIncrement, 1);
-          useSelectionIndex = false;
-        }
-      }
-      if (this.addDecorations) {
-        this.addDecorations(createDecorations(useSelectionIndex ? selectionIndex % batchIncrement : -1, matchesToDecorate));
-      }
-    }, {
-      increment: batchIncrement,
-      until: matchesBetween.length
-    });
-  }
-  async removeDecorationsBetween(editorView, startPos, endPos) {
-    const {
-      decorationSet
-    } = getPluginState(editorView.state);
-    const decorations = decorationSet.find(startPos, endPos);
-    if (decorations.length === 0) {
-      return;
-    }
-    return await this.batchRequests(counter => {
-      let decorationsToRemove = decorations.slice(counter, counter + batchIncrement);
-      if (decorationsToRemove.length === 0) {
-        return false;
-      }
-      // only get those decorations whose from >= startPos
-      for (let i = 0; i < decorationsToRemove.length; i++) {
-        if (decorationsToRemove[i].from >= startPos) {
-          break;
-        }
-        decorationsToRemove = decorationsToRemove.slice(1);
-      }
-      if (this.removeDecorations) {
-        this.removeDecorations(decorationsToRemove);
-      }
-    }, {
-      increment: batchIncrement,
-      until: decorations.length
-    });
-  }
-
-  /**
-   * Calculates Prosemirror start and end positions we want to apply the decorations
-   * between
-   * Also calculates the positions the are the start and end of the user's viewport
-   * so we can apply decorations there first and work outwards
-   */
-  calcDecorationPositions(editorView, containerElement, pmElement) {
-    const containerRect = containerElement.getBoundingClientRect();
-    const pmRect = pmElement.getBoundingClientRect();
-    const viewportStartPos = this.getStartPos(editorView, 0, pmRect.left);
-    const viewportEndPos = this.getEndPos(editorView, containerRect.top + containerRect.height, pmRect.left);
-    return {
-      viewportStartPos,
-      viewportEndPos,
-      startPos: 1,
-      endPos: editorView.state.doc.nodeSize
-    };
-  }
-  getStartPos(editorView, y, x) {
-    const startPos = editorView.posAtCoords({
-      top: y,
-      left: x
-    });
-    return startPos ? startPos.pos : 1;
-  }
-  getEndPos(editorView, y, x) {
-    const maxPos = editorView.state.doc.nodeSize;
-    const endPos = editorView.posAtCoords({
-      top: y,
-      left: x
-    });
-    return endPos ? endPos.pos : maxPos;
-  }
-
-  /**
-   * Util to batch function calls by animation frames
-   * A counter will start at 0 and increment by provided value until reaches limit
-   * Passed in fn receives the counter as a param, return false to skip waiting
-   * for the animation frame for the next call
-   */
-  batchRequests(fn, opts) {
-    let counter = 0;
-    const {
-      increment,
-      until
-    } = opts;
-    return new Promise(resolve => {
-      const batchedFn = () => {
-        let result = fn(counter);
-        while (result === false && counter < until) {
-          counter += increment;
-          result = fn(counter);
-        }
-        if (counter < until) {
-          counter += increment;
-          this.rafId = requestAnimationFrame(batchedFn);
-        } else {
-          this.rafId = undefined;
-          resolve();
-        }
-      };
-      this.rafId = requestAnimationFrame(batchedFn);
-    });
-  }
-}
-const batchDecorations = new BatchDecorations();
-export default batchDecorations;

package/dist/es2019/plugins/find-replace/utils/commands.js

@@ -1,6 +0,0 @@
-export const withScrollIntoView = command => (state, dispatch, view) => command(state, tr => {
-  tr.scrollIntoView();
-  if (dispatch) {
-    dispatch(tr);
-  }
-}, view);

package/dist/es2019/plugins/find-replace/utils/index.js

@@ -1,249 +0,0 @@
-import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { selectedSearchMatchClass, searchMatchClass } from '../styles';
-export function getSelectedText(selection) {
-  let text = '';
-  const selectedContent = selection.content().content;
-  for (let i = 0; i < selectedContent.childCount; i++) {
-    text += selectedContent.child(i).textContent;
-  }
-  return text;
-}
-export const createDecorations = (selectedIndex, matches) => matches.map(({
-  start,
-  end
-}, i) => createDecoration(start, end, i === selectedIndex));
-export const createDecoration = (start, end, isSelected) => {
-  let className = searchMatchClass;
-  if (isSelected) {
-    className += ` ${selectedSearchMatchClass}`;
-  }
-  return Decoration.inline(start, end, {
-    class: className
-  });
-};
-export function findMatches(content, searchText, shouldMatchCase, contentIndex = 0) {
-  let matches = [];
-  const searchTextLength = searchText.length;
-  let textGrouping = null;
-  const collectMatch = textGrouping => {
-    if (!textGrouping) {
-      return;
-    }
-    let {
-      text,
-      pos: relativePos
-    } = textGrouping;
-    const pos = contentIndex + relativePos;
-    if (!shouldMatchCase) {
-      searchText = searchText.toLowerCase();
-      text = text.toLowerCase();
-    }
-    let index = text.indexOf(searchText);
-    while (index !== -1) {
-      // Find the next substring from the end of the first, so that they don't overlap
-      const end = index + searchTextLength;
-      // Add the substring index to the position of the node
-      matches.push({
-        start: pos + index,
-        end: pos + end
-      });
-      index = text.indexOf(searchText, end);
-    }
-  };
-  if (searchTextLength > 0) {
-    content.descendants((node, pos) => {
-      if (node.isText) {
-        if (textGrouping === null) {
-          textGrouping = {
-            text: node.text,
-            pos
-          };
-        } else {
-          textGrouping.text = textGrouping.text + node.text;
-        }
-      } else {
-        collectMatch(textGrouping);
-        textGrouping = null;
-      }
-    });
-    // if there's a dangling text grouping and no non-text node to trigger collectMatch, manually collectMatch
-    if (textGrouping) {
-      collectMatch(textGrouping);
-    }
-  }
-  return matches;
-}
-
-/**
- * Finds index of first item in matches array that comes after user's cursor pos.
- * If `backward` is `true`, finds index of first item that comes before instead.
- */
-export function findSearchIndex(selectionPos, matches, backward = false) {
-  if (backward) {
-    let matchIndex = matches.findIndex(match => match.start >= selectionPos) - 1;
-    if (matchIndex < 0) {
-      matchIndex = matches.length - 1; // wrap around from the end
-    }
-
-    return matchIndex;
-  }
-  return Math.max(matches.findIndex(match => match.start >= selectionPos), 0);
-}
-export const nextIndex = (currentIndex, total) => (currentIndex + 1) % total;
-export const prevIndex = (currentIndex, total) => (currentIndex - 1 + total) % total;
-export const getSelectionForMatch = (selection, doc, index, matches, offset = 0) => {
-  if (matches[index]) {
-    return TextSelection.create(doc, matches[index].start + offset);
-  }
-  return selection;
-};
-export const findDecorationFromMatch = (decorationSet, match) => {
-  if (!match) {
-    return;
-  }
-  const decorations = decorationSet.find(match.start, match.end);
-  return decorations.length ? decorations.find(
-  // decorationSet.find() returns any decorations that touch the specifided
-  // positions, but we want to be stricter
-  decoration => decoration.from === match.start && decoration.to === match.end) : undefined;
-};
-export const removeDecorationsFromSet = (decorationSet, decorationsToRemove, doc) => {
-  const prevDecorations = decorationSet.find();
-
-  // it is essential that we copy the decorations otherwise in some rare cases
-  // prosemirror-view will update our decorationsToRemove array to contain nulls
-  // instead of Decorations which ruins our check for lost decorations below
-  decorationSet = decorationSet.remove(decorationsToRemove.map(decoration =>
-  // copy exists but isn't on the type definition
-  decoration.copy(decoration.from, decoration.to)));
-  const newDecorations = decorationSet.find();
-
-  // there is a bug in prosemirror-view where it can't cope with deleting inline
-  // decorations from a set in some cases (where there are multiple levels of nested
-  // children arrays), and it deletes more decorations than it should
-  // todo: ticket link
-  const lostDecorations = findLostAdjacentDecorations(decorationsToRemove, prevDecorations, newDecorations);
-  if (lostDecorations.length > 0) {
-    decorationSet = decorationSet.add(doc, lostDecorations);
-  }
-  return decorationSet;
-};
-export const removeMatchesFromSet = (decorationSet, matches, doc) => {
-  const decorationsToRemove = matches.filter(match => !!match).map(match => findDecorationFromMatch(decorationSet, match));
-  decorationsToRemove.forEach(decoration => {
-    if (decoration) {
-      decorationSet = removeDecorationsFromSet(decorationSet, [decoration], doc);
-    }
-  });
-  return decorationSet;
-};
-
-/**
- * Finds decorations in prevDecorations that are not in newDecorations or decorationsToRemove
- * These decorations have been lost by Prosemirror during an over eager decoration removal
- * We need to be smart to cope with thousands of decorations without crashing everything
- */
-export const findLostAdjacentDecorations = (decorationsToRemove, prevDecorations, newDecorations) => {
-  let lostDecorations = [];
-  if (prevDecorations.length - decorationsToRemove.length > newDecorations.length) {
-    const position = decorationsToRemove.length > 0 ? decorationsToRemove[0].from : 0;
-    const prevDecorationsStartIdx = findIndexBeforePosition(prevDecorations, position);
-    const newDecorationsStartIdx = findIndexBeforePosition(newDecorations, position);
-    const startIdx = Math.min(prevDecorationsStartIdx, newDecorationsStartIdx);
-    const prevDecorationsToCheck = prevDecorations.slice(startIdx);
-    const newDecorationsToCheck = newDecorations.slice(startIdx);
-    const uniqueInPrev = [];
-    const numToFind = prevDecorationsToCheck.length - newDecorationsToCheck.length;
-    let foundAll = false;
-    let newDecorationsIdxOffset = 0;
-    for (let i = 0; i < prevDecorationsToCheck.length; i++) {
-      const prevDecoration = prevDecorationsToCheck[i];
-      // this was a legit removal, skip and continue
-      if (decorationsToRemove.find(decoration => decoration.from === prevDecoration.from)) {
-        newDecorationsIdxOffset -= 1;
-        continue;
-      }
-      let j = i + newDecorationsIdxOffset;
-
-      // this is a lost decoration
-      if (j >= newDecorationsToCheck.length) {
-        uniqueInPrev.push(prevDecoration);
-        if (uniqueInPrev.length === numToFind) {
-          foundAll = true;
-        }
-      }
-      for (; j < newDecorationsToCheck.length; j++) {
-        const newDecoration = newDecorationsToCheck[j];
-
-        // decoration found in both arrays, skip and continue
-        if (prevDecoration.from === newDecoration.from) {
-          break;
-        }
-
-        // this is a lost decoration
-        if (newDecoration.from > prevDecoration.from || j === newDecorationsToCheck.length - 1) {
-          uniqueInPrev.push(prevDecoration);
-          newDecorationsIdxOffset -= 1;
-          if (uniqueInPrev.length === numToFind) {
-            foundAll = true;
-          }
-          break;
-        }
-      }
-      if (foundAll) {
-        break;
-      }
-    }
-
-    // make sure we ignore any that we wanted to delete
-    lostDecorations = uniqueInPrev.filter(decoration => !decorationsToRemove.find(decorationToRemove => decoration.from === decorationToRemove.from));
-  }
-  return lostDecorations;
-};
-
-/**
- * Searches through array in bumps of 100 to return the index of the first
- * decoration whose 'from' value is before or equal to the position
- */
-export const findIndexBeforePosition = (items, position) => {
-  // jump in batches to cope with arrays with thousands of decorations
-  const increment = 100;
-  let index = 0;
-  for (let i = items.length - 1; i >= 0; i -= increment) {
-    if (items[i].from < position) {
-      // now we have found the 100 range, we can narrow it down to exact index
-      index = i;
-      for (let j = i; j <= items.length - 1; j++) {
-        if (items[j].from <= position) {
-          index = j;
-        } else {
-          break;
-        }
-      }
-      break;
-    }
-    if (i < 100 && i > 0) {
-      i = 100;
-    }
-  }
-  return index;
-};
-
-/**
- * Determines whether a find/replace text Match will be changed as a result
- * of a Step modification to the document. This is evaluated by checking
- * both mapped and unmapped versions of the Step as in different cases the
- * matches will match.
- *
- * **Note:** Match state received here is after step has been applied.
- */
-export const isMatchAffectedByStep = (match, step, tr) => {
-  const {
-    from,
-    to,
-    slice
-  } = step;
-  const sliceSize = slice.content.size;
-  return from + sliceSize >= match.start && to - sliceSize <= match.end || tr.mapping.map(from) + sliceSize >= match.start && tr.mapping.map(to) - sliceSize <= match.end;
-};

package/dist/es2019/utils/array.js

@@ -1,3 +0,0 @@
-export function findUniqueItemsIn(findIn, checkWith, comparator) {
-  return findIn.filter(firstItem => checkWith.findIndex(secondItem => comparator ? comparator(firstItem, secondItem) : firstItem === secondItem) === -1);
-}

package/dist/esm/plugins/find-replace/FindReplaceToolbarButtonWithState.js

@@ -1,157 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import React, { useState, useLayoutEffect } from 'react';
-import { cancelSearchWithAnalytics, replaceWithAnalytics, replaceAllWithAnalytics, findWithAnalytics, findNextWithAnalytics, findPrevWithAnalytics, activateWithAnalytics } from './commands-with-analytics';
-import { blur, toggleMatchCase } from './commands';
-import FindReplaceToolbarButton from './ui/FindReplaceToolbarButton';
-import { TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
-
-// 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
-var useSharedPluginStateNoDebounce = function useSharedPluginStateNoDebounce(api) {
-  var _useState = useState(api === null || api === void 0 ? void 0 : api.findReplace.sharedState.currentState()),
-    _useState2 = _slicedToArray(_useState, 2),
-    state = _useState2[0],
-    setState = _useState2[1];
-  useLayoutEffect(function () {
-    var unsub = api === null || api === void 0 ? void 0 : api.findReplace.sharedState.onChange(function (_ref) {
-      var nextSharedState = _ref.nextSharedState;
-      setState(nextSharedState);
-    });
-    return function () {
-      unsub === null || unsub === void 0 || unsub();
-    };
-  }, [api]);
-  return {
-    findReplaceState: state
-  };
-};
-var FindReplaceToolbarButtonWithState = function FindReplaceToolbarButtonWithState(_ref2) {
-  var _api$analytics;
-  var popupsBoundariesElement = _ref2.popupsBoundariesElement,
-    popupsMountPoint = _ref2.popupsMountPoint,
-    popupsScrollableElement = _ref2.popupsScrollableElement,
-    isToolbarReducedSpacing = _ref2.isToolbarReducedSpacing,
-    editorView = _ref2.editorView,
-    containerElement = _ref2.containerElement,
-    dispatchAnalyticsEvent = _ref2.dispatchAnalyticsEvent,
-    featureFlags = _ref2.featureFlags,
-    takeFullWidth = _ref2.takeFullWidth,
-    api = _ref2.api;
-  var editorAnalyticsAPI = api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions;
-  var _useSharedPluginState = useSharedPluginStateNoDebounce(api),
-    findReplaceState = _useSharedPluginState.findReplaceState;
-  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
-  var runWithEditorFocused = function runWithEditorFocused(fn) {
-    var activeElement = document.activeElement;
-    editorView.focus();
-    fn();
-    activeElement === null || activeElement === void 0 || activeElement.focus();
-  };
-  var dispatchCommand = function dispatchCommand(cmd) {
-    var state = editorView.state,
-      dispatch = editorView.dispatch;
-    cmd(state, dispatch);
-  };
-  var handleActivate = function handleActivate() {
-    runWithEditorFocused(function () {
-      return dispatchCommand(activateWithAnalytics(editorAnalyticsAPI)({
-        triggerMethod: TRIGGER_METHOD.TOOLBAR
-      }));
-    });
-  };
-  var handleFind = function handleFind(keyword) {
-    runWithEditorFocused(function () {
-      return dispatchCommand(findWithAnalytics(editorAnalyticsAPI)({
-        editorView: editorView,
-        containerElement: containerElement,
-        keyword: keyword
-      }));
-    });
-  };
-  var handleFindNext = function handleFindNext(_ref3) {
-    var triggerMethod = _ref3.triggerMethod;
-    runWithEditorFocused(function () {
-      return dispatchCommand(findNextWithAnalytics(editorAnalyticsAPI)({
-        triggerMethod: triggerMethod
-      }));
-    });
-  };
-  var handleFindPrev = function handleFindPrev(_ref4) {
-    var triggerMethod = _ref4.triggerMethod;
-    runWithEditorFocused(function () {
-      return dispatchCommand(findPrevWithAnalytics(editorAnalyticsAPI)({
-        triggerMethod: triggerMethod
-      }));
-    });
-  };
-  var handleReplace = function handleReplace(_ref5) {
-    var triggerMethod = _ref5.triggerMethod,
-      replaceText = _ref5.replaceText;
-    runWithEditorFocused(function () {
-      return dispatchCommand(replaceWithAnalytics(editorAnalyticsAPI)({
-        triggerMethod: triggerMethod,
-        replaceText: replaceText
-      }));
-    });
-  };
-  var handleReplaceAll = function handleReplaceAll(_ref6) {
-    var replaceText = _ref6.replaceText;
-    runWithEditorFocused(function () {
-      return dispatchCommand(replaceAllWithAnalytics(editorAnalyticsAPI)({
-        replaceText: replaceText
-      }));
-    });
-  };
-  var handleFindBlur = function handleFindBlur() {
-    dispatchCommand(blur());
-  };
-  var handleCancel = function handleCancel(_ref7) {
-    var triggerMethod = _ref7.triggerMethod;
-    dispatchCommand(cancelSearchWithAnalytics(editorAnalyticsAPI)({
-      triggerMethod: triggerMethod
-    }));
-    editorView.focus();
-  };
-  var handleToggleMatchCase = function handleToggleMatchCase() {
-    dispatchCommand(toggleMatchCase());
-  };
-  var findReplaceMatchCase = featureFlags.findReplaceMatchCase;
-  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/esm/plugins/find-replace/actions.js

@@ -1,13 +0,0 @@
-export var 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;
-}({});