@atlaskit/editor-core 148.0.0 → 149.0.3

package/dist/esm/plugins/type-ahead/ui/hooks/use-item-insert.js

@@ -0,0 +1,118 @@
+import { useLayoutEffect, useCallback, useRef } from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { closeTypeAhead } from '../../transforms/close-type-ahead';
+import { setSelectionBeforeQuery } from '../../transforms/set-selection-before-query';
+import { insertTypeAheadItem } from '../../commands/insert-type-ahead-item';
+import { CloseSelectionOptions } from '../../constants';
+
+var insertRawQuery = function insertRawQuery(_ref) {
+  var view = _ref.view,
+      setSelectionAt = _ref.setSelectionAt,
+      text = _ref.text,
+      forceFocusOnEditor = _ref.forceFocusOnEditor;
+  var _view$state = view.state,
+      tr = _view$state.tr,
+      schema = _view$state.schema;
+  closeTypeAhead(tr);
+
+  if (text.length > 0) {
+    tr.replaceSelectionWith(schema.text(text));
+
+    if (setSelectionAt === CloseSelectionOptions.BEFORE_TEXT_INSERTED) {
+      setSelectionBeforeQuery(text)(tr);
+    }
+  }
+
+  view.dispatch(tr);
+
+  if (forceFocusOnEditor) {
+    view.focus();
+  }
+};
+
+export var useItemInsert = function useItemInsert(triggerHandler, editorView, items) {
+  var editorViewRef = useRef(editorView);
+  var itemsRef = useRef(items);
+  var onTextInsert = useCallback(function (_ref2) {
+    var setSelectionAt = _ref2.setSelectionAt,
+        text = _ref2.text,
+        forceFocusOnEditor = _ref2.forceFocusOnEditor;
+
+    if (!triggerHandler) {
+      return;
+    }
+
+    var view = editorViewRef.current;
+    insertRawQuery({
+      view: view,
+      setSelectionAt: setSelectionAt,
+      text: text,
+      forceFocusOnEditor: forceFocusOnEditor
+    });
+  }, [triggerHandler]);
+  var onItemInsert = useCallback(function (_ref3) {
+    var mode = _ref3.mode,
+        index = _ref3.index,
+        query = _ref3.query;
+    var sourceListItem = itemsRef.current;
+
+    if (sourceListItem.length === 0 || !triggerHandler) {
+      var text = "".concat(triggerHandler.trigger).concat(query);
+      onTextInsert({
+        forceFocusOnEditor: true,
+        setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
+        text: text
+      });
+      return;
+    }
+
+    var itemToInsert = sourceListItem[index];
+
+    if (!itemToInsert) {
+      return;
+    }
+
+    var view = editorViewRef.current;
+    insertTypeAheadItem(view)({
+      item: itemToInsert,
+      handler: triggerHandler,
+      mode: mode,
+      query: query,
+      sourceListItem: sourceListItem
+    });
+  }, [triggerHandler, onTextInsert]);
+  var onItemMatch = useCallback(function (_ref4) {
+    var mode = _ref4.mode,
+        query = _ref4.query;
+    var _items = itemsRef.current;
+
+    if (_items && _items.length > 1) {
+      return false;
+    }
+
+    if (_items.length === 1) {
+      queueMicrotask(function () {
+        onItemInsert({
+          mode: mode,
+          query: query,
+          index: 0
+        });
+      });
+    } else {
+      var text = "".concat(triggerHandler.trigger).concat(query);
+      queueMicrotask(function () {
+        onTextInsert({
+          forceFocusOnEditor: true,
+          setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
+          text: mode === SelectItemMode.SPACE ? text.concat(' ') : text
+        });
+      });
+    }
+
+    return true;
+  }, [onItemInsert, triggerHandler, onTextInsert]);
+  useLayoutEffect(function () {
+    itemsRef.current = items;
+  }, [items]);
+  return [onItemInsert, onTextInsert, onItemMatch];
+};

package/dist/esm/plugins/type-ahead/ui/hooks/use-load-items.js

@@ -0,0 +1,46 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useRef, useState, useEffect } from 'react';
+import { updateListItem } from '../../commands/update-list-items';
+var EMPTY_LIST_ITEM = [];
+export var useLoadItems = function useLoadItems(triggerHandler, editorView, query) {
+  var _useState = useState(EMPTY_LIST_ITEM),
+      _useState2 = _slicedToArray(_useState, 2),
+      items = _useState2[0],
+      setItems = _useState2[1];
+
+  var componentIsMounted = useRef(true);
+  var editorViewRef = useRef(editorView);
+  useEffect(function () {
+    var getItems = triggerHandler === null || triggerHandler === void 0 ? void 0 : triggerHandler.getItems;
+
+    if (!getItems) {
+      setItems(EMPTY_LIST_ITEM);
+      return;
+    }
+
+    var options = {
+      query: query || '',
+      editorState: editorView.state
+    };
+    var view = editorViewRef.current;
+    getItems(options).then(function (result) {
+      var list = result.length > 0 ? result : EMPTY_LIST_ITEM;
+
+      if (componentIsMounted.current) {
+        setItems(list);
+      }
+
+      queueMicrotask(function () {
+        updateListItem(list)(view.state, view.dispatch);
+      });
+    }); // ignore because EditorView is mutable but we don't want to
+    // call loadItems when it changes, only when the query changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [triggerHandler, query]);
+  useEffect(function () {
+    return function () {
+      componentIsMounted.current = false;
+    };
+  }, []);
+  return items;
+};

package/dist/esm/plugins/type-ahead/ui/hooks/use-on-force-select.js

@@ -0,0 +1,38 @@
+import { useLayoutEffect, useRef } from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { insertTypeAheadItem } from '../../commands/insert-type-ahead-item';
+export var useOnForceSelect = function useOnForceSelect(_ref) {
+  var triggerHandler = _ref.triggerHandler,
+      items = _ref.items,
+      query = _ref.query,
+      editorView = _ref.editorView,
+      closePopup = _ref.closePopup;
+  var editorViewRef = useRef(editorView);
+  useLayoutEffect(function () {
+    if (!query || typeof triggerHandler.forceSelect !== 'function') {
+      return;
+    }
+
+    var item = triggerHandler.forceSelect({
+      items: items,
+      query: query,
+      editorState: editorViewRef.current.state
+    });
+
+    if (!item) {
+      return;
+    }
+
+    var view = editorViewRef.current;
+    closePopup();
+    queueMicrotask(function () {
+      insertTypeAheadItem(view)({
+        item: item,
+        mode: SelectItemMode.SPACE,
+        query: query,
+        handler: triggerHandler,
+        sourceListItem: items
+      });
+    });
+  }, [triggerHandler, closePopup, query, items]);
+};

package/dist/esm/plugins/type-ahead/ui/hooks/use-resize-observer.js

@@ -0,0 +1,48 @@
+import React, { useMemo, useEffect, useContext, useLayoutEffect, createContext } from 'react';
+import { browser } from '@atlaskit/editor-common';
+var Context = /*#__PURE__*/createContext(null);
+export var ResizeObserverContext = Context;
+export var ResizeObserverProvider = /*#__PURE__*/React.memo(function (_ref) {
+  var children = _ref.children;
+  var instance = useMemo(function () {
+    if (!browser.supportsResizeObserver) {
+      return null;
+    }
+
+    return new window.ResizeObserver(function (entries) {
+      entries.forEach(function (entry) {
+        var onResize = entry.target.onResize;
+
+        if (onResize) {
+          onResize(entry);
+        }
+      });
+    });
+  }, []);
+  useEffect(function () {
+    return function () {
+      if (instance) {
+        instance.disconnect();
+      }
+    };
+  }, [instance]);
+  return /*#__PURE__*/React.createElement(Context.Provider, {
+    value: instance
+  }, children);
+});
+export var useResizeObserver = function useResizeObserver(targetRef, onResize) {
+  var resizeObserver = useContext(Context);
+  useLayoutEffect(function () {
+    if (!targetRef || !targetRef.current || resizeObserver === null) {
+      return;
+    }
+
+    var target = targetRef.current;
+    target.onResize = onResize;
+    resizeObserver.observe(target);
+    return function () {
+      resizeObserver.unobserve(target);
+      delete target.onResize;
+    };
+  }, [targetRef, resizeObserver, onResize]);
+};

package/dist/esm/plugins/type-ahead/utils.js

@@ -0,0 +1,88 @@
+import { TextSelection } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
+import { pluginKey as typeAheadPluginKey } from './pm-plugins/key';
+import { updateSelectedIndex } from './commands/update-selected-index';
+import { StatsModifier } from './stats-modifier';
+export var findTypeAheadDecorations = function findTypeAheadDecorations(state) {
+  var selection = state.selection;
+
+  var _typeAheadPluginKey$g = typeAheadPluginKey.getState(state),
+      decorationSet = _typeAheadPluginKey$g.decorationSet;
+
+  if (!decorationSet || decorationSet === DecorationSet.empty || !(selection instanceof TextSelection) || !selection.$cursor) {
+    return null;
+  }
+
+  var pos = selection.$cursor.pos;
+  var decoration = decorationSet.find(pos, pos, function (spec) {
+    return spec === null || spec === void 0 ? void 0 : spec.isTypeAheadDecoration;
+  });
+
+  if (!decoration || decoration.length !== 1) {
+    return null;
+  }
+
+  return decoration[0];
+};
+export var isTypeAheadHandler = function isTypeAheadHandler(handler) {
+  return handler && Object.values(TypeAheadAvailableNodes).includes(handler.id) && typeof handler.trigger === 'string' && typeof handler.selectItem === 'function' && typeof handler.getItems === 'function';
+};
+export var isTypeAheadOpen = function isTypeAheadOpen(editorState) {
+  var _typeAheadPluginKey$g2, _typeAheadPluginKey$g3;
+
+  return (typeAheadPluginKey === null || typeAheadPluginKey === void 0 ? void 0 : (_typeAheadPluginKey$g2 = typeAheadPluginKey.getState(editorState)) === null || _typeAheadPluginKey$g2 === void 0 ? void 0 : (_typeAheadPluginKey$g3 = _typeAheadPluginKey$g2.decorationSet) === null || _typeAheadPluginKey$g3 === void 0 ? void 0 : _typeAheadPluginKey$g3.find().length) > 0;
+};
+export var getPluginState = function getPluginState(editorState) {
+  return typeAheadPluginKey.getState(editorState);
+};
+export var getTypeAheadHandler = function getTypeAheadHandler(editorState) {
+  return typeAheadPluginKey.getState(editorState).triggerHandler;
+};
+export var getTypeAheadQuery = function getTypeAheadQuery(editorState) {
+  return typeAheadPluginKey.getState(editorState).query;
+};
+export var isTypeAheadAllowed = function isTypeAheadAllowed(state) {
+  var isOpen = isTypeAheadOpen(state); // if the TypeAhead is open
+  // we should not allow it
+
+  return !isOpen;
+};
+export var findHandler = function findHandler(id, state) {
+  var pluginState = typeAheadPluginKey.getState(state);
+
+  if (!pluginState || !pluginState.typeAheadHandlers || pluginState.typeAheadHandlers.length === 0) {
+    return null;
+  }
+
+  var typeAheadHandlers = pluginState.typeAheadHandlers;
+  return typeAheadHandlers.find(function (h) {
+    return h.id === id;
+  }) || null;
+};
+export var moveSelectedIndex = function moveSelectedIndex(_ref) {
+  var editorView = _ref.editorView,
+      direction = _ref.direction;
+  return function () {
+    var typeAheadState = getPluginState(editorView.state);
+
+    if (!typeAheadState) {
+      return;
+    }
+
+    var selectedIndex = typeAheadState.selectedIndex,
+        items = typeAheadState.items;
+    var stats = typeAheadState.stats instanceof StatsModifier ? typeAheadState.stats : new StatsModifier();
+    var nextIndex = 0;
+
+    if (direction === 'next') {
+      stats.increaseArrowDown();
+      nextIndex = selectedIndex >= items.length - 1 ? 0 : selectedIndex + 1;
+    } else {
+      stats.increaseArrowUp();
+      nextIndex = selectedIndex === 0 ? items.length - 1 : selectedIndex - 1;
+    }
+
+    updateSelectedIndex(nextIndex)(editorView.state, editorView.dispatch);
+  };
+};

package/dist/esm/plugins/undo-redo/ui/ToolbarUndoRedo/index.js

@@ -16,7 +16,38 @@ import { undo as undoKeymap, redo as redoKeymap, ToolTipContent } from '../../..
 import { ButtonGroup, Separator } from '../../../../ui/styles';
 import ToolbarButton, { TOOLBAR_BUTTON } from '../../../../ui/ToolbarButton';
 import { messages } from '../../messages';
+import { createTypeAheadTools } from '../../../type-ahead/api';
 import { undoFromToolbar, redoFromToolbar } from '../../commands';
+
+var closeTypeAheadAndRunCommand = function closeTypeAheadAndRunCommand(editorView) {
+  return function (command) {
+    if (!editorView) {
+      return;
+    }
+
+    var tool = createTypeAheadTools(editorView);
+
+    if (tool.isOpen()) {
+      tool.close({
+        attachCommand: command,
+        insertCurrentQueryAsRawText: false
+      });
+    } else {
+      command(editorView.state, editorView.dispatch);
+    }
+  };
+};
+
+var forceFocus = function forceFocus(editorView) {
+  return function (command) {
+    closeTypeAheadAndRunCommand(editorView)(command);
+
+    if (!editorView.hasFocus()) {
+      editorView.focus();
+    }
+  };
+};
+
 export var ToolbarUndoRedo = /*#__PURE__*/function (_PureComponent) {
   _inherits(ToolbarUndoRedo, _PureComponent);
 
@@ -39,11 +70,11 @@ export var ToolbarUndoRedo = /*#__PURE__*/function (_PureComponent) {
           formatMessage = _this$props.intl.formatMessage;
 
       var handleUndo = function handleUndo() {
-        undoFromToolbar(editorView.state, editorView.dispatch);
+        forceFocus(editorView)(undoFromToolbar);
       };
 
       var handleRedo = function handleRedo() {
-        redoFromToolbar(editorView.state, editorView.dispatch);
+        forceFocus(editorView)(redoFromToolbar);
       };
 
       var labelUndo = formatMessage(messages.undo);

package/dist/esm/plugins/view-update-subscription/index.js

@@ -31,7 +31,7 @@ var Tracker = function Tracker() {
 var pluginKey = new PluginKey('viewUpdateSubscriptionKey');
 
 var createViewUpdateSubscriptionPlugin = function createViewUpdateSubscriptionPlugin() {
-  var tracker = new Tracker();
+  var tracker;
   var lastUpdateRef = {
     current: null,
     initial: null,
@@ -45,12 +45,14 @@ var createViewUpdateSubscriptionPlugin = function createViewUpdateSubscriptionPl
         return new Plugin({
           key: pluginKey,
           view: function view(editorView) {
-            trackerStore.set(editorView, tracker);
-            return {
-              destroy: function destroy() {
-                trackerStore.delete(editorView);
-              }
-            };
+            tracker = trackerStore.get(editorView);
+
+            if (!tracker) {
+              tracker = new Tracker();
+              trackerStore.set(editorView, tracker);
+            }
+
+            return {};
           }
         });
       };
@@ -71,17 +73,20 @@ var createViewUpdateSubscriptionPlugin = function createViewUpdateSubscriptionPl
         lastUpdateRef.initial = props;
         lastUpdateRef.queued = true;
         queueMicrotask(function () {
-          var _lastUpdateRef$initia;
-
           if (!lastUpdateRef.current || !lastUpdateRef.initial) {
             return;
           }
 
-          tracker.update({
-            newEditorState: lastUpdateRef.current.newEditorState,
-            oldEditorState: (_lastUpdateRef$initia = lastUpdateRef.initial) === null || _lastUpdateRef$initia === void 0 ? void 0 : _lastUpdateRef$initia.oldEditorState,
-            transactions: lastUpdateRef.transactions
-          });
+          if (tracker) {
+            var _lastUpdateRef$initia;
+
+            tracker.update({
+              newEditorState: lastUpdateRef.current.newEditorState,
+              oldEditorState: (_lastUpdateRef$initia = lastUpdateRef.initial) === null || _lastUpdateRef$initia === void 0 ? void 0 : _lastUpdateRef$initia.oldEditorState,
+              transactions: lastUpdateRef.transactions
+            });
+          }
+
           lastUpdateRef.queued = false;
           lastUpdateRef.current = null;
           lastUpdateRef.transactions = [];

package/dist/esm/plugins/view-update-subscription/subscribe/toolbarAndPickerUpdates.js

@@ -2,6 +2,7 @@ import { pluginKey as datePluginKey } from '../../date/pm-plugins/plugin-key';
 import { pluginKey as floatingToolbarPluginKey } from '../../floating-toolbar';
 import { pluginKey as statusPluginKey } from '../../status/plugin-key';
 import { areSameItems } from '../../floating-toolbar/ui/Toolbar';
+import { isTypeAheadOpen } from '../../type-ahead/utils';
 import { trackerStore } from '..';
 
 var areToolbarsSame = function areToolbarsSame(left, right) {
@@ -34,6 +35,14 @@ export var subscribeToToolbarAndPickerUpdates = function subscribeToToolbarAndPi
 
   var subscription = function subscription(_ref) {
     var newEditorState = _ref.newEditorState;
+
+    // TypeAhead has priority in the mobile-bridge
+    // In case it is open we don't need to send
+    // any toolbar updates don't need to be send
+    if (isTypeAheadOpen(newEditorState)) {
+      return;
+    }
+
     var dateState = datePluginKey.getState(newEditorState);
     var statusState = statusPluginKey.getState(newEditorState);
 
@@ -53,9 +62,7 @@ export var subscribeToToolbarAndPickerUpdates = function subscribeToToolbarAndPi
       var oldToolbarConfig = getOldConfigWithNodeInfo(lastUpdatedState);
       var isToolbarEqual = areToolbarsSame(toolbarConfig, oldToolbarConfig);
 
-      if (dateState !== oldDateState || statusState !== oldStatusState || // Sometimes the toolbar changes while a picker is open, we dont care about this
-      // EG A nested status or date node in a table
-      !isToolbarEqual && !statusState.showStatusPickerAt && !dateState.showDatePickerAt) {
+      if (dateState !== oldDateState || statusState !== oldStatusState || !isToolbarEqual && !statusState.showStatusPickerAt && !dateState.showDatePickerAt) {
         shouldCallback = true;
       }
     } else {

package/dist/esm/plugins/view-update-subscription/subscribe/type-ahead-updates.js

@@ -0,0 +1,33 @@
+import { trackerStore } from '..';
+import { pluginKey as typeAheadPluginKey } from '../../type-ahead/pm-plugins/key';
+export var subscribeTypeAheadUpdates = function subscribeTypeAheadUpdates(editorView, cb) {
+  var subscription = function subscription(_ref) {
+    var newEditorState = _ref.newEditorState,
+        oldEditorState = _ref.oldEditorState;
+    var newPluginState = typeAheadPluginKey.getState(newEditorState);
+    var oldPluginState = typeAheadPluginKey.getState(oldEditorState);
+
+    if (!oldPluginState || !newPluginState) {
+      return;
+    }
+
+    cb({
+      oldPluginState: oldPluginState,
+      newPluginState: newPluginState
+    });
+  };
+
+  var tracker = trackerStore.get(editorView);
+
+  if (tracker) {
+    tracker.add(subscription);
+  }
+
+  return function () {
+    var tracker = trackerStore.get(editorView);
+
+    if (tracker) {
+      tracker.remove(subscription);
+    }
+  };
+};

package/dist/esm/test-utils.js

@@ -10,7 +10,14 @@ import { sortByOrder } from './create-editor/sort-by-order';
 import { Preset } from './labs/next/presets/preset';
 import { createSchema } from './create-editor/create-schema';
 import basePlugin from './plugins/base';
+import { analyticsPluginKey } from './plugins/analytics/plugin-key';
+export { createTypeAheadTools } from './plugins/type-ahead/api';
 export { Preset } from './labs/next/presets/preset';
+export function getFireAnalytics(editorView) {
+  var _analyticsPluginKey$g;
+
+  return analyticsPluginKey === null || analyticsPluginKey === void 0 ? void 0 : (_analyticsPluginKey$g = analyticsPluginKey.getState(editorView.state)) === null || _analyticsPluginKey$g === void 0 ? void 0 : _analyticsPluginKey$g.fireAnalytics;
+}
 
 function lightProcessPluginsList(editorPlugins) {
   /**

package/dist/esm/types/empty-state-handler.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/ui/ConfigPanel/Fields/ColorPicker.js

@@ -1,4 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
@@ -8,7 +7,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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) { _defineProperty(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; }
 
-import React, { useState } from 'react';
+import React from 'react';
 import { Field } from '@atlaskit/form';
 import { DEFAULT_BORDER_COLOR } from '../../../ui/ColorPalette/Palettes/common';
 import { isValidHex } from '../utils';
@@ -120,7 +119,6 @@ var ColorPicker = function ColorPicker(props) {
       title = props.title,
       currentColor = props.currentColor,
       colorPalette = props.colorPalette,
-      fieldProps = props.fieldProps,
       onChange = props.onChange,
       onFieldChange = props.onFieldChange;
 
@@ -132,7 +130,6 @@ var ColorPicker = function ColorPicker(props) {
     }
 
     onChange(colorValue);
-    fieldProps.onChange(colorValue);
     onFieldChange(name, currentColor !== colorValue);
   };
 
@@ -158,16 +155,10 @@ var ColorPickerField = function ColorPickerField(_ref) {
   var label = field.label,
       defaultValue = field.defaultValue,
       isRequired = field.isRequired;
-
-  var _useState = useState(defaultValue || ''),
-      _useState2 = _slicedToArray(_useState, 2),
-      currentColor = _useState2[0],
-      setCurrentColor = _useState2[1];
-
   return /*#__PURE__*/React.createElement(Field, {
     name: name,
     isRequired: isRequired,
-    defaultValue: currentColor,
+    defaultValue: defaultValue,
     validate: function validate(value) {
       return _validate(field, value || '');
     }
@@ -179,10 +170,9 @@ var ColorPickerField = function ColorPickerField(_ref) {
     }, "*")), /*#__PURE__*/React.createElement(ColorPicker, {
       name: name,
       title: label,
-      currentColor: currentColor,
+      currentColor: fieldProps.value,
       colorPalette: colorPalette,
-      fieldProps: fieldProps,
-      onChange: setCurrentColor,
+      onChange: fieldProps.onChange,
       onFieldChange: onFieldChange
     })), error && /*#__PURE__*/React.createElement(FieldMessages, {
       error: error,

package/dist/esm/ui/ElementBrowser/ElementBrowser.js

@@ -127,7 +127,8 @@ var ElementBrowser = /*#__PURE__*/function (_PureComponent) {
           onSelectItem = _this$props.onSelectItem,
           showSearch = _this$props.showSearch,
           showCategories = _this$props.showCategories,
-          mode = _this$props.mode;
+          mode = _this$props.mode,
+          emptyStateHandler = _this$props.emptyStateHandler;
       var _this$state2 = this.state,
           categories = _this$state2.categories,
           searchTerm = _this$state2.searchTerm,
@@ -144,7 +145,8 @@ var ElementBrowser = /*#__PURE__*/function (_PureComponent) {
         showSearch: showSearch,
         showCategories: showCategories,
         mode: mode,
-        searchTerm: searchTerm
+        searchTerm: searchTerm,
+        emptyStateHandler: emptyStateHandler
       });
     }
   }]);

package/dist/esm/ui/ElementBrowser/InsertMenu.js

@@ -85,6 +85,7 @@ var InsertMenu = function InsertMenu(_ref) {
     }, /*#__PURE__*/React.createElement(ElementBrowser, {
       mode: "inline",
       getItems: getItems(quickInsertState),
+      emptyStateHandler: quickInsertState === null || quickInsertState === void 0 ? void 0 : quickInsertState.emptyStateHandler,
       onInsertItem: onInsertItem,
       showSearch: true,
       showCategories: false // On page resize we want the InlineElementBrowser to show updated tools/overflow items