@atlaskit/editor-plugin-block-type 1.0.0

package/dist/esm/plugin/ui/ToolbarBlockType/index.js

@@ -0,0 +1,201 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { injectIntl } from 'react-intl-next';
+import { findKeymapByDescription, getAriaKeyshortcuts, tooltip } from '@atlaskit/editor-common/keymaps';
+import { separatorStyles, wrapperStyle } from '@atlaskit/editor-common/styles';
+import { DropdownMenuWithKeyboardNavigation as DropdownMenu } from '@atlaskit/editor-common/ui-menu';
+import { akEditorMenuZIndex } from '@atlaskit/editor-shared-styles';
+import { BlockTypeButton } from './blocktype-button';
+import { blockTypeMenuItemStyle, keyboardShortcut, keyboardShortcutSelect } from './styled';
+// eslint-disable-next-line @repo/internal/react/no-class-components
+var ToolbarBlockType = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(ToolbarBlockType, _React$PureComponent);
+  var _super = _createSuper(ToolbarBlockType);
+  function ToolbarBlockType() {
+    var _this;
+    _classCallCheck(this, ToolbarBlockType);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      active: false,
+      isOpenedByKeyboard: false
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _defineProperty(_assertThisInitialized(_this), "onOpenChange", function (attrs) {
+      _this.setState(_objectSpread(_objectSpread({}, _this.state), {}, {
+        active: attrs.isOpen,
+        isOpenedByKeyboard: attrs.isOpenedByKeyboard
+      }));
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleTriggerClick", function () {
+      _this.onOpenChange({
+        isOpen: !_this.state.active,
+        isOpenedByKeyboard: false
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleTriggerByKeyboard", function (event) {
+      if (event.key === 'Enter' || event.key === ' ') {
+        event.preventDefault();
+        _this.onOpenChange({
+          isOpen: !_this.state.active,
+          isOpenedByKeyboard: true
+        });
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "createItems", function () {
+      var formatMessage = _this.props.intl.formatMessage;
+      var _this$props$pluginSta = _this.props.pluginState,
+        currentBlockType = _this$props$pluginSta.currentBlockType,
+        availableBlockTypes = _this$props$pluginSta.availableBlockTypes;
+      var items = availableBlockTypes.map(function (blockType, index) {
+        var isActive = currentBlockType === blockType;
+        var tagName = blockType.tagName || 'p';
+        var Tag = tagName;
+        var keyMap = findKeymapByDescription(blockType.title.defaultMessage);
+        return {
+          content:
+          // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+          jsx("div", {
+            css: blockTypeMenuItemStyle(tagName, isActive)
+          }, jsx(Tag, null, formatMessage(blockType.title))),
+          value: blockType,
+          label: formatMessage(blockType.title),
+          'aria-label': tooltip(keyMap, formatMessage(blockType.title)),
+          keyShortcuts: getAriaKeyshortcuts(keyMap),
+          key: "".concat(blockType.name, "-").concat(index),
+          elemAfter:
+          // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+          jsx("div", {
+            css: [keyboardShortcut, isActive && keyboardShortcutSelect]
+          }, tooltip(keyMap)),
+          isActive: isActive
+        };
+      });
+      return [{
+        items: items
+      }];
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleSelectBlockType", function (_ref) {
+      var item = _ref.item,
+        _ref$shouldCloseMenu = _ref.shouldCloseMenu,
+        shouldCloseMenu = _ref$shouldCloseMenu === void 0 ? true : _ref$shouldCloseMenu;
+      var blockType = item.value;
+      _this.props.setBlockType(blockType.name);
+      if (shouldCloseMenu) {
+        _this.setState(_objectSpread(_objectSpread({}, _this.state), {}, {
+          active: false
+        }));
+      }
+    });
+    return _this;
+  }
+  _createClass(ToolbarBlockType, [{
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$state = this.state,
+        active = _this$state.active,
+        isOpenedByKeyboard = _this$state.isOpenedByKeyboard;
+      var _this$props = this.props,
+        popupsMountPoint = _this$props.popupsMountPoint,
+        popupsBoundariesElement = _this$props.popupsBoundariesElement,
+        popupsScrollableElement = _this$props.popupsScrollableElement,
+        isSmall = _this$props.isSmall,
+        isReducedSpacing = _this$props.isReducedSpacing,
+        _this$props$pluginSta2 = _this$props.pluginState,
+        currentBlockType = _this$props$pluginSta2.currentBlockType,
+        blockTypesDisabled = _this$props$pluginSta2.blockTypesDisabled,
+        availableBlockTypes = _this$props$pluginSta2.availableBlockTypes,
+        formatMessage = _this$props.intl.formatMessage;
+      var isHeadingDisabled = !availableBlockTypes.some(function (blockType) {
+        return blockType.nodeName === 'heading';
+      });
+      if (isHeadingDisabled) {
+        return null;
+      }
+      var blockTypeTitles = availableBlockTypes.filter(function (blockType) {
+        return blockType.name === currentBlockType.name;
+      }).map(function (blockType) {
+        return blockType.title;
+      });
+      if (!this.props.isDisabled && !blockTypesDisabled) {
+        var items = this.createItems();
+        return (
+          // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+          jsx("span", {
+            css: wrapperStyle
+          }, jsx(DropdownMenu, {
+            items: items,
+            onOpenChange: this.onOpenChange,
+            onItemActivated: this.handleSelectBlockType,
+            isOpen: active,
+            mountTo: popupsMountPoint,
+            boundariesElement: popupsBoundariesElement,
+            scrollableElement: popupsScrollableElement,
+            zIndex: akEditorMenuZIndex,
+            fitHeight: 360,
+            fitWidth: 106,
+            shouldUseDefaultRole: true,
+            shouldFocusFirstItem: function shouldFocusFirstItem() {
+              if (isOpenedByKeyboard) {
+                // eslint-disable-next-line @repo/internal/react/no-set-state-inside-render
+                _this2.setState(_objectSpread(_objectSpread({}, _this2.state), {}, {
+                  isOpenedByKeyboard: false
+                }));
+              }
+              return isOpenedByKeyboard;
+            }
+          }, jsx(BlockTypeButton, {
+            isSmall: isSmall,
+            isReducedSpacing: isReducedSpacing,
+            selected: active,
+            disabled: false,
+            title: blockTypeTitles[0],
+            onClick: this.handleTriggerClick,
+            onKeyDown: this.handleTriggerByKeyboard,
+            formatMessage: formatMessage,
+            "aria-expanded": active
+          })), jsx("span", {
+            // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+            css: separatorStyles
+          }))
+        );
+      }
+      return (
+        // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+        jsx("span", {
+          css: wrapperStyle
+        }, jsx(BlockTypeButton, {
+          isSmall: isSmall,
+          isReducedSpacing: isReducedSpacing,
+          selected: active,
+          disabled: true,
+          title: blockTypeTitles[0],
+          onClick: this.handleTriggerClick,
+          onKeyDown: this.handleTriggerByKeyboard,
+          formatMessage: formatMessage,
+          "aria-expanded": active
+        }), jsx("span", {
+          // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+          css: separatorStyles
+        }))
+      );
+    }
+  }]);
+  return ToolbarBlockType;
+}(React.PureComponent);
+export default injectIntl(ToolbarBlockType);

package/dist/esm/plugin/ui/ToolbarBlockType/styled.js

@@ -0,0 +1,20 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7;
+/** @jsx jsx */
+import { css } from '@emotion/react';
+import { headingsSharedStyles } from '@atlaskit/editor-common/styles';
+import { shortcutStyle } from '@atlaskit/editor-shared-styles/shortcut';
+import { N400 } from '@atlaskit/theme/colors';
+export var blockTypeMenuItemStyle = function blockTypeMenuItemStyle(tagName, selected) {
+  // TEMP FIX: See https://product-fabric.atlassian.net/browse/ED-13878
+  var selectedStyle = selected ? "".concat(tagName, " { color: ", "var(--ds-text, white)", " !important; }") : '';
+  return function (themeProps) {
+    return css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    ", ";\n    > {\n      h1,\n      h2,\n      h3,\n      h4,\n      h5,\n      h6 {\n        margin-top: 0;\n      }\n    }\n    ", ";\n  "])), headingsSharedStyles(themeProps), selectedStyle);
+  };
+};
+export var keyboardShortcut = css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  ", "\n  margin-left: ", ";\n"])), shortcutStyle, "var(--ds-space-200, 16px)");
+export var keyboardShortcutSelect = css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  color: ", ";\n"])), "var(--ds-icon, ".concat(N400, ")"));
+export var buttonContentStyle = css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  display: flex;\n  min-width: 80px;\n  align-items: center;\n  overflow: hidden;\n  justify-content: center;\n  flex-direction: column;\n  padding: ", ";\n"])), "var(--ds-space-075, 6px)");
+export var buttonContentReducedSpacingStyle = css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  padding: ", ";\n"])), "var(--ds-space-100, 8px)");
+export var wrapperSmallStyle = css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  margin-left: ", ";\n  min-width: 40px;\n"])), "var(--ds-space-050, 4px)");
+export var expandIconWrapperStyle = css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  margin-left: -8px;\n"])));

package/dist/esm/plugin/ui/ToolbarBlockType/toolbar-messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export var toolbarMessages = defineMessages({
+  textStyles: {
+    id: 'fabric.editor.textStyles',
+    defaultMessage: 'Text styles',
+    description: 'Menu provides access to various heading styles or normal text'
+  }
+});

package/dist/esm/plugin/utils.js

@@ -0,0 +1,77 @@
+import { createWrappingJoinRule } from '@atlaskit/editor-common/utils';
+import { createRule } from '@atlaskit/prosemirror-input-rules';
+import { WRAPPER_BLOCK_TYPES } from './block-types';
+export var isNodeAWrappingBlockNode = function isNodeAWrappingBlockNode(node) {
+  if (!node) {
+    return false;
+  }
+  return WRAPPER_BLOCK_TYPES.some(function (blockNode) {
+    return blockNode.name === node.type.name;
+  });
+};
+export var createJoinNodesRule = function createJoinNodesRule(match, nodeType) {
+  return createWrappingJoinRule({
+    nodeType: nodeType,
+    match: match,
+    getAttrs: {},
+    joinPredicate: function joinPredicate(_, node) {
+      return node.type === nodeType;
+    }
+  });
+};
+export var createWrappingTextBlockRule = function createWrappingTextBlockRule(_ref) {
+  var match = _ref.match,
+    nodeType = _ref.nodeType,
+    getAttrs = _ref.getAttrs;
+  var handler = function handler(state, match, start, end) {
+    var fixedStart = Math.max(start, 1);
+    var $start = state.doc.resolve(fixedStart);
+    var attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    var nodeBefore = $start.node(-1);
+    if (nodeBefore && !nodeBefore.canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
+      return null;
+    }
+    return state.tr.delete(fixedStart, end).setBlockType(fixedStart, fixedStart, nodeType, attrs);
+  };
+  return createRule(match, handler);
+};
+
+/**
+ * Function will create a list of wrapper blocks present in a selection.
+ */
+function getSelectedWrapperNodes(state) {
+  var nodes = [];
+  if (state.selection) {
+    var _state$selection = state.selection,
+      $from = _state$selection.$from,
+      $to = _state$selection.$to;
+    var _state$schema$nodes = state.schema.nodes,
+      blockquote = _state$schema$nodes.blockquote,
+      panel = _state$schema$nodes.panel,
+      orderedList = _state$schema$nodes.orderedList,
+      bulletList = _state$schema$nodes.bulletList,
+      listItem = _state$schema$nodes.listItem,
+      codeBlock = _state$schema$nodes.codeBlock,
+      decisionItem = _state$schema$nodes.decisionItem,
+      decisionList = _state$schema$nodes.decisionList,
+      taskItem = _state$schema$nodes.taskItem,
+      taskList = _state$schema$nodes.taskList;
+    state.doc.nodesBetween($from.pos, $to.pos, function (node) {
+      if (node.isBlock && [blockquote, panel, orderedList, bulletList, listItem, codeBlock, decisionItem, decisionList, taskItem, taskList].indexOf(node.type) >= 0) {
+        nodes.push(node.type);
+      }
+    });
+  }
+  return nodes;
+}
+
+/**
+ * Function will check if changing block types: Paragraph, Heading is enabled.
+ */
+export function areBlockTypesDisabled(state) {
+  var nodesTypes = getSelectedWrapperNodes(state);
+  var panel = state.schema.nodes.panel;
+  return nodesTypes.filter(function (type) {
+    return type !== panel;
+  }).length > 0;
+}

package/dist/esm/styles.js

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

package/dist/types/consts.d.ts

@@ -0,0 +1 @@
+export { BLOCK_QUOTE, CODE_BLOCK, HEADING_1, HEADING_2, HEADING_3, HEADING_4, HEADING_5, HEADING_6, NORMAL_TEXT, PANEL, } from './plugin/block-types';

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { blockTypePlugin } from './plugin';
+export type { BlockTypePlugin } from './plugin';
+export type { BlockTypePluginOptions, BlockType } from './plugin/types';
+export type { BlockTypeState } from './plugin/pm-plugins/main';
+export type { InputMethod } from './plugin/commands';
+export type { DropdownItem } from './plugin/ui/ToolbarBlockType';

package/dist/types/messages.d.ts

@@ -0,0 +1,2 @@
+export { messages } from './plugin/messages';
+export { toolbarMessages } from './plugin/ui/ToolbarBlockType/toolbar-messages';

package/dist/types/plugin/block-types.d.ts

@@ -0,0 +1,19 @@
+import type { BlockType } from './types';
+export declare const NORMAL_TEXT: BlockType;
+export declare const HEADING_1: BlockType;
+export declare const HEADING_2: BlockType;
+export declare const HEADING_3: BlockType;
+export declare const HEADING_4: BlockType;
+export declare const HEADING_5: BlockType;
+export declare const HEADING_6: BlockType;
+export declare const BLOCK_QUOTE: BlockType;
+export declare const CODE_BLOCK: BlockType;
+export declare const PANEL: BlockType;
+export declare const OTHER: BlockType;
+export declare const TEXT_BLOCK_TYPES: BlockType[];
+export declare const WRAPPER_BLOCK_TYPES: BlockType[];
+export declare const ALL_BLOCK_TYPES: BlockType[];
+export declare const HEADINGS_BY_LEVEL: Record<number, BlockType>;
+export declare const HEADINGS_BY_NAME: {
+    [blockType: string]: BlockType;
+};

package/dist/types/plugin/commands/block-type.d.ts

@@ -0,0 +1,18 @@
+import type { EditorAnalyticsAPI, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command, HeadingLevelsAndNormalText } from '@atlaskit/editor-common/types';
+export type InputMethod = INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.SHORTCUT | INPUT_METHOD.FORMATTING | INPUT_METHOD.KEYBOARD;
+export declare function setBlockType(name: string): Command;
+export declare function setBlockTypeWithAnalytics(name: string, inputMethod: InputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+export declare function setNormalText(): Command;
+export declare function setNormalTextWithAnalytics(inputMethod: InputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+export declare const setHeadingWithAnalytics: (newHeadingLevel: HeadingLevelsAndNormalText, inputMethod: InputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+/**
+ *
+ * @param name - block type name
+ * @param inputMethod - input method
+ * @param editorAnalyticsApi - analytics api, undefined if not available either because it failed to load or wasn't added
+ * otherwise Editor becomes very sad and crashes
+ * @returns - command that inserts block type
+ */
+export declare const insertBlockQuoteWithAnalytics: (inputMethod: InputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const cleanUpAtTheStartOfDocument: Command;

package/dist/types/plugin/commands/delete-and-move-cursor.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from '@atlaskit/editor-common/types';
+/**
+ * Fixes cursor position after delete for list/task in panel and table
+ *
+ * ED-13873 fixes a bug where after deleting a list the cursor would move
+ * to the cell to the right. Uses setSelection to position the cursor as expected after deleting.
+ *
+ * @param state EditorState
+ * @param dispatch CommandDispatch
+ * @returns boolean
+ */
+export declare const deleteAndMoveCursor: Command;

package/dist/types/plugin/commands/delete-block-content.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Prevent removing the block when deleting block content
+ *
+ * @param state EditorState
+ * @param dispatch CommandDispatch
+ * @returns boolean
+ */
+export declare function deleteBlockContent(isNodeAWrappingBlockNode: (node?: PMNode | null) => boolean): Command;

package/dist/types/plugin/commands/index.d.ts

@@ -0,0 +1,9 @@
+export { cleanUpAtTheStartOfDocument, insertBlockQuoteWithAnalytics, setBlockType, setBlockTypeWithAnalytics, setHeadingWithAnalytics, setNormalText, setNormalTextWithAnalytics, } from './block-type';
+export type { InputMethod } from './block-type';
+export { deleteAndMoveCursor } from './delete-and-move-cursor';
+export { deleteBlockContent } from './delete-block-content';
+/**
+ * @private
+ * @deprecated use import from @atlaskit/editor-common/commands
+ */
+export { setHeading } from '@atlaskit/editor-common/commands';

package/dist/types/plugin/consts.d.ts

@@ -0,0 +1 @@
+export declare const HEADING_KEYS: number[];

package/dist/types/plugin/index.d.ts

@@ -0,0 +1,18 @@
+import type { Command, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { InputMethod } from './commands/block-type';
+import type { BlockTypeState } from './pm-plugins/main';
+import type { BlockTypePluginOptions } from './types';
+export type BlockTypePlugin = NextEditorPlugin<'blockType', {
+    pluginConfiguration: BlockTypePluginOptions | undefined;
+    dependencies: [OptionalPlugin<typeof analyticsPlugin>];
+    sharedState: BlockTypeState | undefined;
+    actions: {
+        insertBlockQuote: (inputMethod: InputMethod) => Command;
+        setBlockType: (name: string, inputMethod: InputMethod) => Command;
+    };
+}>;
+declare const blockTypePlugin: BlockTypePlugin;
+export { blockTypePlugin };
+export { pluginKey } from './pm-plugins/main';
+export type { BlockTypeState } from './pm-plugins/main';

package/dist/types/plugin/messages.d.ts

@@ -0,0 +1,152 @@
+export declare const messages: {
+    normal: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading1: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading1Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading2: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading2Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading3: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading3Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading4: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading4Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading5: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading5Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading6: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading6Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    blockquote: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    blockquoteDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    codeblock: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    codeblockDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    infoPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    infoPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    notePanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    notePanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    successPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    successPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    warningPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    warningPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    errorPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    errorPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    customPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    customPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    other: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types/plugin/pm-plugins/input-rule.d.ts

@@ -0,0 +1,6 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+declare function inputRulePlugin(editorAnalyticsAPI: EditorAnalyticsAPI | undefined, schema: Schema, featureFlags: FeatureFlags): SafePlugin | undefined;
+export default inputRulePlugin;

package/dist/types/plugin/pm-plugins/keymap.d.ts

@@ -0,0 +1,5 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+export default function keymapPlugin(editorAnalyticsApi: EditorAnalyticsAPI | undefined, schema: Schema, _featureFlags: FeatureFlags): SafePlugin;

package/dist/types/plugin/pm-plugins/main.d.ts

@@ -0,0 +1,17 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { BlockType } from '../types';
+export type BlockTypeState = {
+    currentBlockType: BlockType;
+    blockTypesDisabled: boolean;
+    availableBlockTypes: BlockType[];
+    availableWrapperBlockTypes: BlockType[];
+};
+export declare const pluginKey: PluginKey<BlockTypeState>;
+export declare const createPlugin: (editorAnalyticsApi: EditorAnalyticsAPI | undefined, dispatch: (eventName: string | PluginKey, data: any) => void, lastNodeMustBeParagraph?: boolean) => SafePlugin<{
+    currentBlockType: BlockType;
+    blockTypesDisabled: boolean;
+    availableBlockTypes: BlockType[];
+    availableWrapperBlockTypes: BlockType[];
+}>;

package/dist/types/plugin/styles.d.ts

@@ -0,0 +1,2 @@
+import type { ThemeProps } from '@atlaskit/theme/types';
+export declare const blocktypeStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;

package/dist/types/plugin/types.d.ts

@@ -0,0 +1,22 @@
+import type { MessageDescriptor } from 'react-intl-next';
+import type { AllowedBlockTypes, HeadingLevelsAndNormalText } from '@atlaskit/editor-common/types';
+import type { NodeSpec } from '@atlaskit/editor-prosemirror/model';
+export type BlockTypeName = 'normal' | 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'blockquote' | 'codeblock' | 'panel' | 'notePanel' | 'successPanel' | 'warningPanel' | 'errorPanel' | 'other';
+export interface BlockType {
+    name: string;
+    title: MessageDescriptor;
+    nodeName: string;
+    tagName?: string;
+    level?: HeadingLevelsAndNormalText;
+}
+export interface BlockTypeNode {
+    name: AllowedBlockTypes;
+    node: NodeSpec;
+}
+export interface BlockTypePluginOptions {
+    lastNodeMustBeParagraph?: boolean;
+    allowBlockType?: {
+        exclude?: Array<AllowedBlockTypes>;
+    };
+    isUndoRedoButtonsEnabled?: boolean;
+}

package/dist/types/plugin/ui/ToolbarBlockType/blocktype-button.d.ts

@@ -0,0 +1,22 @@
+/** @jsx jsx */
+import React from 'react';
+import type { MessageDescriptor, WrappedComponentProps } from 'react-intl-next';
+export interface BlockTypeButtonProps {
+    isSmall?: boolean;
+    isReducedSpacing?: boolean;
+    'aria-expanded': React.AriaAttributes['aria-expanded'];
+    selected: boolean;
+    disabled: boolean;
+    title: MessageDescriptor;
+    onClick(e: React.MouseEvent): void;
+    onKeyDown(e: React.KeyboardEvent): void;
+    formatMessage: WrappedComponentProps['intl']['formatMessage'];
+}
+export declare const messages: {
+    textStyles: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export declare const BlockTypeButton: React.StatelessComponent<BlockTypeButtonProps>;