@atlaskit/editor-core 181.0.1 → 182.0.0

package/dist/es2019/plugins/floating-toolbar/ui/EmojiPickerButton.js

@@ -28,8 +28,11 @@ export const EmojiPickerButton = props => {
   };
   const updateEmoji = emoji => {
     setIsPopupOpen(false);
-    props.editorView && props.editorView.focus();
     props.onChange && props.onChange(emoji);
+    requestAnimationFrame(() => {
+      var _props$editorView;
+      (_props$editorView = props.editorView) === null || _props$editorView === void 0 ? void 0 : _props$editorView.focus();
+    });
   };
   const isDetachedElement = el => !document.body.contains(el);
   const handleEmojiClickOutside = e => {
@@ -41,6 +44,11 @@ export const EmojiPickerButton = props => {
       togglePopup();
     }
   };
+  const handleEmojiPressEscape = () => {
+    var _buttonRef$current;
+    setIsPopupOpen(false);
+    (_buttonRef$current = buttonRef.current) === null || _buttonRef$current === void 0 ? void 0 : _buttonRef$current.focus();
+  };
   const renderPicker = providers => {
     if (!providers.emojiProvider) {
       return null;
@@ -49,7 +57,8 @@ export const EmojiPickerButton = props => {
       emojiProvider: providers.emojiProvider,
       onSelection: updateEmoji,
       onPickerRef: () => {},
-      handleClickOutside: handleEmojiClickOutside
+      handleClickOutside: handleEmojiClickOutside,
+      handleEscapeKeydown: handleEmojiPressEscape
     });
   };
   const renderPopup = () => {
@@ -66,7 +75,8 @@ export const EmojiPickerButton = props => {
       // if the toolbar is scrollable, this will be mounted in the root editor
       // we need an index of > 500 to display over it
       ,
-      zIndex: props.setDisableParentScroll ? 600 : undefined
+      zIndex: props.setDisableParentScroll ? 600 : undefined,
+      focusTrap: true
     }, jsx(WithProviders, {
       providers: ['emojiProvider'],
       providerFactory: props.providerFactory,

package/dist/es2019/plugins/floating-toolbar/ui/SimpleModal.js

@@ -26,7 +26,10 @@ export const SimpleModal = props => {
     testId: testId ? `${testId}-cancel-button` : undefined
   }, cancelButtonLabel), /*#__PURE__*/React.createElement(Button, {
     appearance: "warning",
-    onClick: () => onConfirm(),
+    onClick: () => {
+      onConfirm();
+      onClose();
+    },
     testId: testId ? `${testId}-confirm-button` : undefined
   }, okButtonLabel)));
 };

package/dist/es2019/plugins/floating-toolbar/ui/Toolbar.js

@@ -9,7 +9,6 @@ import { hexToEditorBackgroundPaletteColor } from '@atlaskit/editor-palette';
 import { themed } from '@atlaskit/theme/components';
 import { borderRadius, gridSize } from '@atlaskit/theme/constants';
 import { DN70 } from '@atlaskit/theme/colors';
-import { getFeatureFlags } from '../../feature-flags-context';
 import { compareArrays, shallowEqual } from '../utils';
 import { showConfirmDialog } from '../pm-plugins/toolbar-data/commands';
 import Button from './Button';
@@ -43,12 +42,13 @@ const ToolbarItems = /*#__PURE__*/React.memo(({
   extensionsProvider,
   node,
   setDisableScroll,
-  mountRef
+  mountRef,
+  featureFlags
 }) => {
   const emojiAndColourPickerMountPoint = scrollable ? popupsMountPoint || (editorView === null || editorView === void 0 ? void 0 : editorView.dom.closest('.fabric-editor-popup-scroll-parent')) || (editorView === null || editorView === void 0 ? void 0 : editorView.dom.closest('.ak-editor-content-area')) || undefined : popupsMountPoint;
   const {
     useSomewhatSemanticTextColorNames
-  } = editorView ? getFeatureFlags(editorView.state) : {
+  } = featureFlags || {
     useSomewhatSemanticTextColorNames: false
   };
   return jsx(ButtonGroup, null, items.filter(item => !item.hidden).map((item, idx) => {
@@ -197,7 +197,7 @@ const ToolbarItems = /*#__PURE__*/React.memo(({
         }
         const {
           extendFloatingToolbar
-        } = getFeatureFlags(editorView.state) || {};
+        } = featureFlags || {};
         if (!extendFloatingToolbar) {
           return null;
         }
@@ -451,7 +451,8 @@ class Toolbar extends Component {
     }, jsx(ToolbarItems, _extends({}, this.props, {
       setDisableScroll: this.setDisableScroll.bind(this),
       mountRef: this.mountRef,
-      mounted: this.state.mounted
+      mounted: this.state.mounted,
+      featureFlags: this.props.featureFlags
     }))), scrollable && jsx(ScrollButtons, {
       intl: intl,
       scrollContainerRef: this.scrollContainerRef,

package/dist/es2019/plugins/hyperlink/Toolbar.js

@@ -12,8 +12,6 @@ import { LINKPICKER_HEIGHT_IN_PX, RECENT_SEARCH_HEIGHT_IN_PX, RECENT_SEARCH_WIDT
 import { HyperlinkToolbarAppearance } from './HyperlinkToolbarAppearance';
 import { addAnalytics, ACTION_SUBJECT_ID } from '../analytics';
 import { buildVisitedLinkPayload, buildOpenedSettingsPayload } from '../../utils/linking-utils';
-import { getFeatureFlags } from '../feature-flags-context';
-
 /* type guard for edit links */
 function isEditLink(linkMark) {
   return linkMark.pos !== undefined;
@@ -43,10 +41,10 @@ function getLinkText(activeLinkMark, state) {
   }
   return activeLinkMark.node.text;
 }
-const getSettingsButtonGroup = (state, intl) => {
+const getSettingsButtonGroup = (state, intl, featureFlags) => {
   const {
     floatingToolbarLinkSettingsButton
-  } = getFeatureFlags(state);
+  } = featureFlags;
   return floatingToolbarLinkSettingsButton === 'true' ? [{
     type: 'separator'
   }, {
@@ -59,7 +57,7 @@ const getSettingsButtonGroup = (state, intl) => {
     target: '_blank'
   }] : [];
 };
-export const getToolbarConfig = options => (state, intl, providerFactory) => {
+export const getToolbarConfig = (options, featureFlags) => (state, intl, providerFactory) => {
   const {
     formatMessage
   } = intl;
@@ -72,7 +70,7 @@ export const getToolbarConfig = options => (state, intl, providerFactory) => {
     lpLinkPicker,
     lpLinkPickerFocusTrap,
     preventPopupOverflow
-  } = getFeatureFlags(state);
+  } = featureFlags;
   const shouldEnableFocusTrap = lpLinkPicker && lpLinkPickerFocusTrap;
   if (linkState && linkState.activeLinkMark) {
     const {
@@ -167,21 +165,20 @@ export const getToolbarConfig = options => (state, intl, providerFactory) => {
                 formatMessage: formatMessage,
                 markType: state.schema.marks.link
               }]
-            }, ...getSettingsButtonGroup(state, intl)],
+            }, ...getSettingsButtonGroup(state, intl, featureFlags)],
             scrollable: true
           };
         }
       case 'EDIT_INSERTED':
       case 'INSERT':
         {
-          var _options$linkPicker, _options$linkPicker$p;
           let link;
           if (isEditLink(activeLinkMark) && activeLinkMark.node) {
             const linkMark = activeLinkMark.node.marks.filter(mark => mark.type === state.schema.marks.link);
             link = linkMark[0] && linkMark[0].attrs.href;
           }
           const displayText = isEditLink(activeLinkMark) ? getLinkText(activeLinkMark, state) : linkState.activeText;
-          const popupHeight = lpLinkPicker && Boolean(options === null || options === void 0 ? void 0 : (_options$linkPicker = options.linkPicker) === null || _options$linkPicker === void 0 ? void 0 : (_options$linkPicker$p = _options$linkPicker.plugins) === null || _options$linkPicker$p === void 0 ? void 0 : _options$linkPicker$p.length) ? LINKPICKER_HEIGHT_IN_PX : RECENT_SEARCH_HEIGHT_IN_PX;
+          const popupHeight = lpLinkPicker ? LINKPICKER_HEIGHT_IN_PX : RECENT_SEARCH_HEIGHT_IN_PX;
           return {
             ...hyperLinkToolbar,
             preventPopupOverflow,
@@ -200,6 +197,7 @@ export const getToolbarConfig = options => (state, intl, providerFactory) => {
                   view: view,
                   key: idx,
                   linkPickerOptions: options === null || options === void 0 ? void 0 : options.linkPicker,
+                  featureFlags: featureFlags,
                   displayUrl: link,
                   displayText: displayText || '',
                   providerFactory: providerFactory,

package/dist/es2019/plugins/hyperlink/index.js

@@ -9,67 +9,71 @@ import { getToolbarConfig } from './Toolbar';
 import { tooltip, addLink } from '../../keymaps';
 import { IconLink } from '../quick-insert/assets';
 import { messages } from '../insert-block/ui/ToolbarInsertBlock/messages';
-const hyperlinkPlugin = options => ({
-  name: 'hyperlink',
-  marks() {
-    return [{
-      name: 'link',
-      mark: link
-    }];
-  },
-  pmPlugins() {
-    var _options$cardOptions;
-    // Skip analytics if card provider is available, as they will be
-    // sent on handleRejected upon attempting to resolve smart link.
-    const skipAnalytics = !!(options !== null && options !== void 0 && (_options$cardOptions = options.cardOptions) !== null && _options$cardOptions !== void 0 && _options$cardOptions.provider);
-    return [{
-      name: 'hyperlink',
-      plugin: ({
-        dispatch
-      }) => plugin(dispatch, options === null || options === void 0 ? void 0 : options.editorAppearance)
-    }, {
-      name: 'fakeCursorToolbarPlugin',
-      plugin: () => fakeCursorToolbarPlugin
-    }, {
-      name: 'hyperlinkInputRule',
-      plugin: ({
-        schema,
-        featureFlags
-      }) => createInputRulePlugin(schema, skipAnalytics, featureFlags)
-    }, {
-      name: 'hyperlinkKeymap',
-      plugin: () => createKeymapPlugin(skipAnalytics)
-    }];
-  },
-  pluginsOptions: {
-    quickInsert: ({
-      formatMessage
-    }) => [{
-      id: 'hyperlink',
-      title: formatMessage(messages.link),
-      description: formatMessage(messages.linkDescription),
-      keywords: ['hyperlink', 'url'],
-      priority: 1200,
-      keyshortcut: tooltip(addLink),
-      icon: () => /*#__PURE__*/React.createElement(IconLink, null),
-      action(insert, state) {
-        const tr = insert(undefined);
-        tr.setMeta(stateKey, {
-          type: LinkAction.SHOW_INSERT_TOOLBAR,
-          inputMethod: INPUT_METHOD.QUICK_INSERT
-        });
-        return addAnalytics(state, tr, {
-          action: ACTION.INVOKED,
-          actionSubject: ACTION_SUBJECT.TYPEAHEAD,
-          actionSubjectId: ACTION_SUBJECT_ID.TYPEAHEAD_LINK,
-          attributes: {
+const hyperlinkPlugin = (options = {}, api) => {
+  var _api$dependencies, _api$dependencies$fea;
+  const featureFlags = (api === null || api === void 0 ? void 0 : (_api$dependencies = api.dependencies) === null || _api$dependencies === void 0 ? void 0 : (_api$dependencies$fea = _api$dependencies.featureFlags) === null || _api$dependencies$fea === void 0 ? void 0 : _api$dependencies$fea.sharedState.currentState()) || {};
+  return {
+    name: 'hyperlink',
+    marks() {
+      return [{
+        name: 'link',
+        mark: link
+      }];
+    },
+    pmPlugins() {
+      var _options$cardOptions;
+      // Skip analytics if card provider is available, as they will be
+      // sent on handleRejected upon attempting to resolve smart link.
+      const skipAnalytics = !!(options !== null && options !== void 0 && (_options$cardOptions = options.cardOptions) !== null && _options$cardOptions !== void 0 && _options$cardOptions.provider);
+      return [{
+        name: 'hyperlink',
+        plugin: ({
+          dispatch
+        }) => plugin(dispatch, options === null || options === void 0 ? void 0 : options.editorAppearance)
+      }, {
+        name: 'fakeCursorToolbarPlugin',
+        plugin: () => fakeCursorToolbarPlugin
+      }, {
+        name: 'hyperlinkInputRule',
+        plugin: ({
+          schema,
+          featureFlags
+        }) => createInputRulePlugin(schema, skipAnalytics, featureFlags)
+      }, {
+        name: 'hyperlinkKeymap',
+        plugin: () => createKeymapPlugin(skipAnalytics)
+      }];
+    },
+    pluginsOptions: {
+      quickInsert: ({
+        formatMessage
+      }) => [{
+        id: 'hyperlink',
+        title: formatMessage(messages.link),
+        description: formatMessage(messages.linkDescription),
+        keywords: ['hyperlink', 'url'],
+        priority: 1200,
+        keyshortcut: tooltip(addLink),
+        icon: () => /*#__PURE__*/React.createElement(IconLink, null),
+        action(insert, state) {
+          const tr = insert(undefined);
+          tr.setMeta(stateKey, {
+            type: LinkAction.SHOW_INSERT_TOOLBAR,
             inputMethod: INPUT_METHOD.QUICK_INSERT
-          },
-          eventType: EVENT_TYPE.UI
-        });
-      }
-    }],
-    floatingToolbar: getToolbarConfig(options)
-  }
-});
+          });
+          return addAnalytics(state, tr, {
+            action: ACTION.INVOKED,
+            actionSubject: ACTION_SUBJECT.TYPEAHEAD,
+            actionSubjectId: ACTION_SUBJECT_ID.TYPEAHEAD_LINK,
+            attributes: {
+              inputMethod: INPUT_METHOD.QUICK_INSERT
+            },
+            eventType: EVENT_TYPE.UI
+          });
+        }
+      }],
+      floatingToolbar: getToolbarConfig(options, featureFlags)
+    }
+  };
+};
 export default hyperlinkPlugin;

package/dist/es2019/plugins/hyperlink/ui/HyperlinkAddToolbar/index.js

@@ -5,7 +5,6 @@ import HyperlinkAddToolbarComp from './HyperlinkAddToolbar';
 import { INPUT_METHOD } from '../../../analytics/types';
 import { stateKey as pluginKey } from '../../pm-plugins/main';
 import WithPluginState from '../../../../ui/WithPluginState';
-import { getFeatureFlags } from '../../../feature-flags-context';
 import { EditorLinkPicker } from '../EditorLinkPicker';
 /**
  * Wraps around the editor's onSubmit handler so that the plugin can interface with the link picker
@@ -29,7 +28,8 @@ export default class HyperlinkAddToolbar extends React.PureComponent {
       providerFactory,
       view,
       onCancel,
-      invokeMethod
+      invokeMethod,
+      featureFlags
     } = this.props;
     return /*#__PURE__*/React.createElement(WithProviders, {
       providers: ['activityProvider', 'searchProvider'],
@@ -47,7 +47,7 @@ export default class HyperlinkAddToolbar extends React.PureComponent {
         }) => {
           const {
             lpLinkPicker
-          } = getFeatureFlags(view.state);
+          } = featureFlags;
           if (lpLinkPicker) {
             return /*#__PURE__*/React.createElement(EditorLinkPicker, _extends({
               view: view,

package/dist/es2019/plugins/index.js

@@ -64,4 +64,5 @@ export { default as avatarGroupPlugin } from './avatar-group';
 export { default as viewUpdateSubscriptionPlugin } from './view-update-subscription';
 export { default as beforePrimaryToolbarPlugin } from './before-primaryToolbar';
 export { default as codeBidiWarningPlugin } from './code-bidi-warning';
-export { default as copyButtonPlugin } from './copy-button';
+export { default as copyButtonPlugin } from './copy-button';
+export { default as borderPlugin } from './border';

package/dist/es2019/plugins/insert-block/ui/ToolbarInsertBlock/index.js

@@ -470,7 +470,8 @@ export class ToolbarInsertBlock extends React.PureComponent {
       offset: [0, 3],
       mountTo: popupsMountPoint,
       boundariesElement: popupsBoundariesElement,
-      scrollableElement: popupsScrollableElement
+      scrollableElement: popupsScrollableElement,
+      focusTrap: true
     }, jsx(EmojiPickerWithListeners, {
       emojiProvider: emojiProvider,
       onSelection: this.handleSelectedEmoji,

package/dist/es2019/plugins/list/actions/outdent-list-items-selected.js

@@ -6,10 +6,9 @@ import { isListNode, isListItemNode, joinSiblingLists, JoinDirection } from '../
 import { findFirstParentListItemNode, findRootParentListNode } from '../utils/find';
 import { normalizeListItemsSelection, createListNodeRange } from '../utils/selection';
 import { GapCursorSelection } from '../../selection/gap-cursor-selection';
-import { getFeatureFlags } from '../../feature-flags-context';
 import { storeRestartListsAttributes, getRestartListsAttributes } from '../utils/analytics';
 import { OUTDENT_SCENARIOS } from '@atlaskit/editor-common/analytics';
-export const outdentListItemsSelected = (tr, state) => {
+export const outdentListItemsSelected = (tr, state, featureFlags) => {
   const originalSelection = tr.selection;
   const normalizedSelection = normalizeListItemsSelection({
     selection: tr.selection,
@@ -46,7 +45,8 @@ export const outdentListItemsSelected = (tr, state) => {
       extractListItemsRangeFromList({
         tr,
         range: mappedRange,
-        state
+        state,
+        featureFlags
       });
       hasNormalizedToPositionLiftedOut = hasNormalizedToPositionLiftedOut || oldTo >= range.from && oldTo < range.to;
       hasNormalizedFromPositionLiftedOut = hasNormalizedFromPositionLiftedOut || oldFrom >= range.from && oldFrom < range.to;
@@ -177,7 +177,8 @@ const outdentRangeToParentList = ({
 const extractListItemsRangeFromList = ({
   tr,
   range,
-  state
+  state,
+  featureFlags
 }) => {
   const list = range.parent;
   const $start = tr.doc.resolve(range.start);
@@ -200,7 +201,6 @@ const extractListItemsRangeFromList = ({
     }
   }
   let nextList = list.copy(Fragment.empty);
-  const featureFlags = getFeatureFlags(state);
   let nextListStartNumber;
   if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
     // if splitting a numbered list, keep the splitted item

package/dist/es2019/plugins/list/commands/index.js

@@ -18,7 +18,7 @@ import { outdentList } from './outdent-list';
 import { indentList } from './indent-list';
 import { moveTargetIntoList } from '../utils/replace-content';
 export { outdentList, indentList };
-export const enterKeyCommand = (state, dispatch) => {
+export const enterKeyCommand = featureFlags => (state, dispatch) => {
   const {
     selection
   } = state;
@@ -35,7 +35,7 @@ export const enterKeyCommand = (state, dispatch) => {
       /** Check if the wrapper has any visible content */
       const wrapperHasContent = hasVisibleContent(wrapper);
       if (!wrapperHasContent) {
-        return outdentList(INPUT_METHOD.KEYBOARD)(state, dispatch);
+        return outdentList(INPUT_METHOD.KEYBOARD, featureFlags)(state, dispatch);
       } else if (!hasParentNodeOfType(codeBlock)(selection)) {
         return splitListItem(listItem)(state, dispatch);
       }
@@ -43,13 +43,13 @@ export const enterKeyCommand = (state, dispatch) => {
   }
   return false;
 };
-export const backspaceKeyCommand = (state, dispatch) => {
+export const backspaceKeyCommand = featureFlags => (state, dispatch) => {
   return baseCommand.chainCommands(listBackspace,
   // if we're at the start of a list item, we need to either backspace
   // directly to an empty list item above, or outdent this node
   filter([isEmptySelectionAtStart,
   // list items might have multiple paragraphs; only do this at the first one
-  isFirstChildOfParent, isInsideListItem], baseCommand.chainCommands(deletePreviousEmptyListItem, outdentList(INPUT_METHOD.KEYBOARD))),
+  isFirstChildOfParent, isInsideListItem], baseCommand.chainCommands(deletePreviousEmptyListItem, outdentList(INPUT_METHOD.KEYBOARD, featureFlags))),
   // if we're just inside a paragraph node (or gapcursor is shown) and backspace, then try to join
   // the text to the previous list item, if one exists
   filter([isEmptySelectionAtStart, canJoinToPreviousListItem], joinToPreviousListItem))(state, dispatch);

package/dist/es2019/plugins/list/commands/outdent-list.js

@@ -6,8 +6,7 @@ import { findFirstParentListNode } from '../utils/find';
 import { getCommonListAnalyticsAttributes, getRestartListsAttributes } from '../utils/analytics';
 import { outdentListItemsSelected as outdentListAction } from '../actions/outdent-list-items-selected';
 import { closeHistory } from 'prosemirror-history';
-import { getFeatureFlags } from '../../feature-flags-context';
-export function outdentList(inputMethod = INPUT_METHOD.KEYBOARD) {
+export function outdentList(inputMethod = INPUT_METHOD.KEYBOARD, featureFlags) {
   return function (state, dispatch) {
     if (!isInsideListItem(state)) {
       return false;
@@ -25,13 +24,12 @@ export function outdentList(inputMethod = INPUT_METHOD.KEYBOARD) {
     closeHistory(state.tr);
     const actionSubjectId = isBulletList(parentListNode.node) ? ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
     let customTr = state.tr;
-    outdentListAction(customTr, state);
+    outdentListAction(customTr, state, featureFlags);
     if (!customTr || !customTr.docChanged) {
       // Even though this is a non-operation, we don't want to send this event to the browser. Because if we return false, the browser will move the focus to another place
       // If inside table cell and can't outdent list, then let it handle by table keymap
       return !isInsideTableCell(state);
     }
-    const featureFlags = getFeatureFlags(state);
     const restartListsAttributes = {};
     if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
       const {

package/dist/es2019/plugins/list/index.js

@@ -11,81 +11,84 @@ import { IconList, IconListNumber } from '../quick-insert/assets';
   Toolbar buttons to bullet and ordered list can be found in
   packages/editor/editor-core/src/plugins/toolbar-lists-indentation/ui/Toolbar.tsx
  */
-const listPlugin = options => ({
-  name: 'list',
-  nodes() {
-    return [{
-      name: 'bulletList',
-      node: bulletList
-    }, {
-      name: 'orderedList',
-      node: options !== null && options !== void 0 && options.restartNumberedLists ? orderedListWithOrder : orderedList
-    }, {
-      name: 'listItem',
-      node: listItem
-    }];
-  },
-  pmPlugins() {
-    return [{
-      name: 'list',
-      plugin: ({
-        dispatch
-      }) => createPlugin(dispatch)
-    }, {
-      name: 'listInputRule',
-      plugin: ({
-        schema,
-        featureFlags
-      }) => inputRulePlugin(schema, featureFlags)
-    }, {
-      name: 'listKeymap',
-      plugin: () => keymapPlugin()
-    }];
-  },
-  pluginsOptions: {
-    quickInsert: ({
-      formatMessage
-    }) => [{
-      id: 'unorderedList',
-      title: formatMessage(messages.unorderedList),
-      description: formatMessage(messages.unorderedListDescription),
-      keywords: ['ul', 'unordered'],
-      priority: 1100,
-      keyshortcut: tooltip(toggleBulletList),
-      icon: () => /*#__PURE__*/React.createElement(IconList, null),
-      action(insert, state) {
-        const tr = insert(state.schema.nodes.bulletList.createChecked({}, state.schema.nodes.listItem.createChecked({}, state.schema.nodes.paragraph.createChecked())));
-        return addAnalytics(state, tr, {
-          action: ACTION.INSERTED,
-          actionSubject: ACTION_SUBJECT.LIST,
-          actionSubjectId: ACTION_SUBJECT_ID.FORMAT_LIST_BULLET,
-          eventType: EVENT_TYPE.TRACK,
-          attributes: {
-            inputMethod: INPUT_METHOD.QUICK_INSERT
-          }
-        });
-      }
-    }, {
-      id: 'orderedList',
-      title: formatMessage(messages.orderedList),
-      description: formatMessage(messages.orderedListDescription),
-      keywords: ['ol', 'ordered'],
-      priority: 1200,
-      keyshortcut: tooltip(toggleOrderedList),
-      icon: () => /*#__PURE__*/React.createElement(IconListNumber, null),
-      action(insert, state) {
-        const tr = insert(state.schema.nodes.orderedList.createChecked({}, state.schema.nodes.listItem.createChecked({}, state.schema.nodes.paragraph.createChecked())));
-        return addAnalytics(state, tr, {
-          action: ACTION.INSERTED,
-          actionSubject: ACTION_SUBJECT.LIST,
-          actionSubjectId: ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER,
-          eventType: EVENT_TYPE.TRACK,
-          attributes: {
-            inputMethod: INPUT_METHOD.QUICK_INSERT
-          }
-        });
-      }
-    }]
-  }
-});
+const listPlugin = (options, api) => {
+  const featureFlags = (api === null || api === void 0 ? void 0 : api.dependencies.featureFlags.sharedState.currentState()) || {};
+  return {
+    name: 'list',
+    nodes() {
+      return [{
+        name: 'bulletList',
+        node: bulletList
+      }, {
+        name: 'orderedList',
+        node: options !== null && options !== void 0 && options.restartNumberedLists ? orderedListWithOrder : orderedList
+      }, {
+        name: 'listItem',
+        node: listItem
+      }];
+    },
+    pmPlugins() {
+      return [{
+        name: 'list',
+        plugin: ({
+          dispatch
+        }) => createPlugin(dispatch, featureFlags)
+      }, {
+        name: 'listInputRule',
+        plugin: ({
+          schema,
+          featureFlags
+        }) => inputRulePlugin(schema, featureFlags)
+      }, {
+        name: 'listKeymap',
+        plugin: () => keymapPlugin(featureFlags)
+      }];
+    },
+    pluginsOptions: {
+      quickInsert: ({
+        formatMessage
+      }) => [{
+        id: 'unorderedList',
+        title: formatMessage(messages.unorderedList),
+        description: formatMessage(messages.unorderedListDescription),
+        keywords: ['ul', 'unordered'],
+        priority: 1100,
+        keyshortcut: tooltip(toggleBulletList),
+        icon: () => /*#__PURE__*/React.createElement(IconList, null),
+        action(insert, state) {
+          const tr = insert(state.schema.nodes.bulletList.createChecked({}, state.schema.nodes.listItem.createChecked({}, state.schema.nodes.paragraph.createChecked())));
+          return addAnalytics(state, tr, {
+            action: ACTION.INSERTED,
+            actionSubject: ACTION_SUBJECT.LIST,
+            actionSubjectId: ACTION_SUBJECT_ID.FORMAT_LIST_BULLET,
+            eventType: EVENT_TYPE.TRACK,
+            attributes: {
+              inputMethod: INPUT_METHOD.QUICK_INSERT
+            }
+          });
+        }
+      }, {
+        id: 'orderedList',
+        title: formatMessage(messages.orderedList),
+        description: formatMessage(messages.orderedListDescription),
+        keywords: ['ol', 'ordered'],
+        priority: 1200,
+        keyshortcut: tooltip(toggleOrderedList),
+        icon: () => /*#__PURE__*/React.createElement(IconListNumber, null),
+        action(insert, state) {
+          const tr = insert(state.schema.nodes.orderedList.createChecked({}, state.schema.nodes.listItem.createChecked({}, state.schema.nodes.paragraph.createChecked())));
+          return addAnalytics(state, tr, {
+            action: ACTION.INSERTED,
+            actionSubject: ACTION_SUBJECT.LIST,
+            actionSubjectId: ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER,
+            eventType: EVENT_TYPE.TRACK,
+            attributes: {
+              inputMethod: INPUT_METHOD.QUICK_INSERT
+            }
+          });
+        }
+      }]
+    }
+  };
+};
 export default listPlugin;

package/dist/es2019/plugins/list/pm-plugins/input-rules/create-list-input-rule.js

@@ -1,4 +1,5 @@
-import { ruleWithAnalytics, createWrappingJoinRule } from '../../../../utils/input-rules';
+import { ruleWithAnalytics } from '../../../../utils/input-rules';
+import { createWrappingJoinRule } from './wrapping-join-rule';
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '../../../analytics';
 import { JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST } from '@atlaskit/editor-common/analytics';
 const getOrder = matchResult => Number(matchResult[1]);
@@ -44,6 +45,7 @@ export function createRuleForListType({
     };
   }
   const inputRule = createWrappingJoinRule({
+    featureFlags,
     match: expression,
     nodeType: listType,
     getAttrs,

package/dist/es2019/plugins/list/pm-plugins/input-rules/index.js

@@ -14,7 +14,8 @@ export default function inputRulePlugin(schema, featureFlags) {
       // because of issue where product converted the
       // character into an escaped version.
       expression: /^\s*([\*\-\u2022]) $/,
-      listType: bulletList
+      listType: bulletList,
+      featureFlags
     }));
   }
   const expression = featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists ? /((^[1-9]{1}[0-9]{0,2})|^(0))[\.\)] $/ : /^(1)[\.\)] $/;