@atlaskit/editor-plugin-text-formatting 0.1.0

package/dist/esm/ui/Toolbar/hooks/responsive-toolbar-buttons.js

@@ -0,0 +1,50 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { useMemo } from 'react';
+import { DefaultButtonsMenu, DefaultButtonsToolbar, ResponsiveCustomButtonToolbar, ResponsiveCustomMenu } from '../constants';
+export var useResponsiveIconTypeButtons = function useResponsiveIconTypeButtons(_ref) {
+  var toolbarSize = _ref.toolbarSize,
+    responsivenessEnabled = _ref.responsivenessEnabled;
+  var iconTypeList = useMemo(function () {
+    return ResponsiveCustomButtonToolbar[toolbarSize];
+  }, [toolbarSize]);
+  return responsivenessEnabled ? iconTypeList : DefaultButtonsToolbar;
+};
+export var useResponsiveIconTypeMenu = function useResponsiveIconTypeMenu(_ref2) {
+  var toolbarSize = _ref2.toolbarSize,
+    responsivenessEnabled = _ref2.responsivenessEnabled;
+  var iconTypeList = useMemo(function () {
+    return ResponsiveCustomMenu[toolbarSize];
+  }, [toolbarSize]);
+  return responsivenessEnabled ? iconTypeList : DefaultButtonsMenu;
+};
+export var useResponsiveToolbarButtons = function useResponsiveToolbarButtons(_ref3) {
+  var icons = _ref3.icons,
+    toolbarSize = _ref3.toolbarSize,
+    responsivenessEnabled = _ref3.responsivenessEnabled;
+  var iconTypeList = useResponsiveIconTypeButtons({
+    toolbarSize: toolbarSize,
+    responsivenessEnabled: responsivenessEnabled
+  });
+  var iconsPosition = useMemo(function () {
+    return icons.reduce(function (acc, icon) {
+      if (!icon || !icon.iconMark) {
+        return acc;
+      }
+      var isIconSingleButton = iconTypeList.includes(icon.iconMark);
+      if (isIconSingleButton) {
+        return {
+          dropdownItems: acc.dropdownItems,
+          singleItems: [].concat(_toConsumableArray(acc.singleItems), [icon])
+        };
+      }
+      return {
+        dropdownItems: [].concat(_toConsumableArray(acc.dropdownItems), [icon]),
+        singleItems: acc.singleItems
+      };
+    }, {
+      dropdownItems: [],
+      singleItems: []
+    });
+  }, [icons, iconTypeList]);
+  return iconsPosition;
+};

package/dist/esm/ui/Toolbar/index.js

@@ -0,0 +1,174 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+/** @jsx jsx */
+import { useEffect, useMemo, useState } from 'react';
+import { jsx } from '@emotion/react';
+import { injectIntl } from 'react-intl-next';
+import { usePreviousState } from '@atlaskit/editor-common/hooks';
+import { toolbarMessages } from '@atlaskit/editor-common/messages';
+import { buttonGroupStyle, separatorStyles, wrapperStyle } from '@atlaskit/editor-common/styles';
+import { Announcer } from '@atlaskit/editor-common/ui';
+import { compareItemsArrays, isArrayContainsContent } from '../../utils';
+import { FormattingTextDropdownMenu } from './dropdown-menu';
+import { useClearIcon } from './hooks/clear-formatting-icon';
+import { useFormattingIcons, useHasFormattingActived } from './hooks/formatting-icons';
+import { useResponsiveIconTypeMenu, useResponsiveToolbarButtons } from './hooks/responsive-toolbar-buttons';
+import { MoreButton } from './more-button';
+import { SingleToolbarButtons } from './single-toolbar-buttons';
+var ToolbarFormatting = function ToolbarFormatting(_ref) {
+  var _usePreviousState;
+  var shouldUseResponsiveToolbar = _ref.shouldUseResponsiveToolbar,
+    popupsMountPoint = _ref.popupsMountPoint,
+    popupsBoundariesElement = _ref.popupsBoundariesElement,
+    popupsScrollableElement = _ref.popupsScrollableElement,
+    editorView = _ref.editorView,
+    toolbarSize = _ref.toolbarSize,
+    isReducedSpacing = _ref.isReducedSpacing,
+    isToolbarDisabled = _ref.isToolbarDisabled,
+    intl = _ref.intl,
+    editorAnalyticsAPI = _ref.editorAnalyticsAPI;
+  var editorState = useMemo(function () {
+    return editorView.state;
+  }, [editorView.state]);
+  var _useState = useState(''),
+    _useState2 = _slicedToArray(_useState, 2),
+    message = _useState2[0],
+    setMessage = _useState2[1];
+  var defaultIcons = useFormattingIcons({
+    editorState: editorState,
+    intl: intl,
+    isToolbarDisabled: isToolbarDisabled,
+    editorAnalyticsAPI: editorAnalyticsAPI
+  });
+  var clearIcon = useClearIcon({
+    editorState: editorState,
+    intl: intl,
+    editorAnalyticsAPI: editorAnalyticsAPI
+  });
+  var menuIconTypeList = useResponsiveIconTypeMenu({
+    toolbarSize: toolbarSize,
+    responsivenessEnabled: shouldUseResponsiveToolbar
+  });
+  var hasFormattingActive = useHasFormattingActived({
+    editorState: editorView.state,
+    iconTypeList: menuIconTypeList
+  });
+  var _useResponsiveToolbar = useResponsiveToolbarButtons({
+      icons: defaultIcons,
+      toolbarSize: toolbarSize,
+      responsivenessEnabled: shouldUseResponsiveToolbar
+    }),
+    dropdownItems = _useResponsiveToolbar.dropdownItems,
+    singleItems = _useResponsiveToolbar.singleItems;
+  var clearFormattingStatus = intl.formatMessage(toolbarMessages.textFormattingOff);
+  var superscriptOffSubscriptOnStatus = intl.formatMessage(toolbarMessages.superscriptOffSubscriptOn);
+  var subscriptOffSuperscriptOnStatus = intl.formatMessage(toolbarMessages.subscriptOffSuperscriptOn);
+  var activeItems = [].concat(_toConsumableArray(dropdownItems), _toConsumableArray(singleItems)).filter(function (item) {
+    return item.isActive;
+  });
+  var prevActiveItems = (_usePreviousState = usePreviousState(activeItems)) !== null && _usePreviousState !== void 0 ? _usePreviousState : [];
+  var fromSuperscriptToSubscript = isArrayContainsContent(activeItems, 'Subscript') && isArrayContainsContent(prevActiveItems, 'Superscript');
+  var fromSubscriptToSuperscript = isArrayContainsContent(activeItems, 'Superscript') && isArrayContainsContent(prevActiveItems, 'Subscript');
+  var comparedItems;
+  var screenReaderMessage = '';
+  if (prevActiveItems && activeItems.length > prevActiveItems.length) {
+    comparedItems = compareItemsArrays(activeItems, prevActiveItems);
+    screenReaderMessage = intl.formatMessage(toolbarMessages.on, {
+      formattingType: comparedItems[0].content
+    });
+  } else {
+    comparedItems = compareItemsArrays(prevActiveItems, activeItems);
+    if (comparedItems && comparedItems.length) {
+      var _activeItems$;
+      screenReaderMessage = intl.formatMessage(toolbarMessages.off, {
+        formattingType: comparedItems[0].content
+      });
+      if (((_activeItems$ = activeItems[0]) === null || _activeItems$ === void 0 ? void 0 : _activeItems$.content) === 'Code') {
+        screenReaderMessage = intl.formatMessage(toolbarMessages.codeOn, {
+          textFormattingOff: (prevActiveItems === null || prevActiveItems === void 0 ? void 0 : prevActiveItems.length) > 1 ? clearFormattingStatus : screenReaderMessage
+        });
+      }
+      if (fromSuperscriptToSubscript) {
+        screenReaderMessage = superscriptOffSubscriptOnStatus;
+      }
+      if (fromSubscriptToSuperscript) {
+        screenReaderMessage = subscriptOffSuperscriptOnStatus;
+      }
+    }
+  }
+
+  // handle 'Clear formatting' status for screen readers
+  if (!(activeItems !== null && activeItems !== void 0 && activeItems.length) && (prevActiveItems === null || prevActiveItems === void 0 ? void 0 : prevActiveItems.length) > 1) {
+    screenReaderMessage = clearFormattingStatus;
+  }
+  var items = useMemo(function () {
+    if (!clearIcon) {
+      return dropdownItems;
+    }
+    return [].concat(_toConsumableArray(dropdownItems), [clearIcon]);
+  }, [clearIcon, dropdownItems]);
+  var moreFormattingButtonLabel = intl.formatMessage(toolbarMessages.moreFormatting);
+  useEffect(function () {
+    if (screenReaderMessage) {
+      setMessage(screenReaderMessage);
+    }
+  }, [screenReaderMessage]);
+  return (
+    // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+    jsx("span", {
+      css: buttonGroupStyle
+    }, message && jsx(Announcer, {
+      ariaLive: "assertive",
+      text: message,
+      ariaRelevant: "additions",
+      delay: 250
+    }), jsx(SingleToolbarButtons, {
+      items: singleItems,
+      editorView: editorView,
+      isReducedSpacing: isReducedSpacing
+    }), jsx("span", {
+      css: wrapperStyle
+    }, isToolbarDisabled ? jsx("div", null, jsx(MoreButton, {
+      label: moreFormattingButtonLabel,
+      isReducedSpacing: isReducedSpacing,
+      isDisabled: true,
+      isSelected: false,
+      "aria-expanded": undefined,
+      "aria-pressed": undefined
+    })) : jsx(FormattingTextDropdownMenu, {
+      popupsMountPoint: popupsMountPoint,
+      popupsBoundariesElement: popupsBoundariesElement,
+      popupsScrollableElement: popupsScrollableElement,
+      editorView: editorView,
+      isReducedSpacing: isReducedSpacing,
+      moreButtonLabel: moreFormattingButtonLabel,
+      hasFormattingActive: hasFormattingActive,
+      items: items
+    }), jsx("span", {
+      css: separatorStyles
+    })))
+  );
+};
+var Toolbar = function Toolbar(_ref2) {
+  var popupsMountPoint = _ref2.popupsMountPoint,
+    popupsScrollableElement = _ref2.popupsScrollableElement,
+    toolbarSize = _ref2.toolbarSize,
+    isReducedSpacing = _ref2.isReducedSpacing,
+    editorView = _ref2.editorView,
+    isToolbarDisabled = _ref2.isToolbarDisabled,
+    shouldUseResponsiveToolbar = _ref2.shouldUseResponsiveToolbar,
+    intl = _ref2.intl,
+    editorAnalyticsAPI = _ref2.editorAnalyticsAPI;
+  return jsx(ToolbarFormatting, {
+    popupsMountPoint: popupsMountPoint,
+    popupsScrollableElement: popupsScrollableElement,
+    toolbarSize: toolbarSize,
+    isReducedSpacing: isReducedSpacing,
+    editorView: editorView,
+    isToolbarDisabled: isToolbarDisabled,
+    shouldUseResponsiveToolbar: shouldUseResponsiveToolbar,
+    intl: intl,
+    editorAnalyticsAPI: editorAnalyticsAPI
+  });
+};
+export default injectIntl(Toolbar);

package/dist/esm/ui/Toolbar/more-button.js

@@ -0,0 +1,33 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { triggerWrapperStyles } from '@atlaskit/editor-common/styles';
+import { ToolbarButton } from '@atlaskit/editor-common/ui-menu';
+import MoreIcon from '@atlaskit/icon/glyph/editor/more';
+export var MoreButton = /*#__PURE__*/React.memo(function (_ref) {
+  var label = _ref.label,
+    ariaExpanded = _ref['aria-expanded'],
+    isReducedSpacing = _ref.isReducedSpacing,
+    isSelected = _ref.isSelected,
+    isDisabled = _ref.isDisabled,
+    onClick = _ref.onClick,
+    onKeyDown = _ref.onKeyDown;
+  return jsx(ToolbarButton, {
+    disabled: isDisabled,
+    selected: isSelected,
+    onClick: onClick,
+    onKeyDown: onKeyDown,
+    spacing: isReducedSpacing ? 'none' : 'default',
+    title: label,
+    iconBefore:
+    // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+    jsx("div", {
+      css: triggerWrapperStyles
+    }, jsx(MoreIcon, {
+      label: ""
+    })),
+    "aria-expanded": ariaExpanded,
+    "aria-label": label,
+    "aria-haspopup": true
+  });
+});

package/dist/esm/ui/Toolbar/single-toolbar-buttons.js

@@ -0,0 +1,38 @@
+/** @jsx jsx */
+import React, { useCallback } from 'react';
+import { jsx } from '@emotion/react';
+import { buttonGroupStyle } from '@atlaskit/editor-common/styles';
+import { ToolbarButton } from '@atlaskit/editor-common/ui-menu';
+export var SingleToolbarButtons = /*#__PURE__*/React.memo(function (_ref) {
+  var items = _ref.items,
+    isReducedSpacing = _ref.isReducedSpacing,
+    editorView = _ref.editorView;
+  var onClick = useCallback(function (command) {
+    return function () {
+      command(editorView.state, editorView.dispatch);
+      return false;
+    };
+  }, [editorView.state, editorView.dispatch]);
+  return (
+    // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+    jsx("span", {
+      css: buttonGroupStyle
+    }, items.map(function (item) {
+      var _item$ariaLabel;
+      return jsx(ToolbarButton, {
+        key: item.key,
+        testId: "editor-toolbar__".concat(String(item.content)),
+        buttonId: item.buttonId,
+        spacing: isReducedSpacing ? 'none' : 'default',
+        onClick: onClick(item.command),
+        selected: item.isActive,
+        disabled: item.isDisabled,
+        title: item.tooltipElement,
+        iconBefore: item.iconElement,
+        "aria-pressed": item.isActive,
+        "aria-label": (_item$ariaLabel = item['aria-label']) !== null && _item$ariaLabel !== void 0 ? _item$ariaLabel : String(item.content),
+        "aria-keyshortcuts": item['aria-keyshortcuts']
+      });
+    }))
+  );
+});

package/dist/esm/ui/Toolbar/types.js

@@ -0,0 +1,10 @@
+export var IconTypes = /*#__PURE__*/function (IconTypes) {
+  IconTypes["strong"] = "strong";
+  IconTypes["em"] = "em";
+  IconTypes["underline"] = "underline";
+  IconTypes["strike"] = "strike";
+  IconTypes["code"] = "code";
+  IconTypes["subscript"] = "subscript";
+  IconTypes["superscript"] = "superscript";
+  return IconTypes;
+}({});

package/dist/esm/utils/cell-selection.js

@@ -0,0 +1,5 @@
+export var cellSelectionNodesBetween = function cellSelectionNodesBetween(selection, doc, f, startPos) {
+  selection.forEachCell(function (cell, cellPos) {
+    doc.nodesBetween(cellPos, cellPos + cell.nodeSize, f, startPos);
+  });
+};

package/dist/esm/utils.js

@@ -0,0 +1,75 @@
+import { anyMarkActive } from '@atlaskit/editor-common/mark';
+import { FORMATTING_MARK_TYPES, FORMATTING_NODE_TYPES } from './commands/clear-formatting';
+export var hasCode = function hasCode(state, pos) {
+  var code = state.schema.marks.code;
+  var node = pos >= 0 && state.doc.nodeAt(pos);
+  if (node) {
+    return !!node.marks.filter(function (mark) {
+      return mark.type === code;
+    }).length;
+  }
+  return false;
+};
+
+/**
+ * Determine if a mark (with specific attribute values) exists anywhere in the selection.
+ */
+export var markActive = function markActive(state, mark) {
+  var _state$selection = state.selection,
+    from = _state$selection.from,
+    to = _state$selection.to,
+    empty = _state$selection.empty;
+  // When the selection is empty, only the active marks apply.
+  if (empty) {
+    return !!mark.isInSet(state.tr.storedMarks || state.selection.$from.marks());
+  }
+  // For a non-collapsed selection, the marks on the nodes matter.
+  var found = false;
+  state.doc.nodesBetween(from, to, function (node) {
+    found = found || mark.isInSet(node.marks);
+  });
+  return found;
+};
+var blockStylingIsPresent = function blockStylingIsPresent(state) {
+  var _state$selection2 = state.selection,
+    from = _state$selection2.from,
+    to = _state$selection2.to;
+  var isBlockStyling = false;
+  state.doc.nodesBetween(from, to, function (node) {
+    if (FORMATTING_NODE_TYPES.indexOf(node.type.name) !== -1) {
+      isBlockStyling = true;
+      return false;
+    }
+    return true;
+  });
+  return isBlockStyling;
+};
+var marksArePresent = function marksArePresent(state) {
+  var activeMarkTypes = FORMATTING_MARK_TYPES.filter(function (mark) {
+    if (!!state.schema.marks[mark]) {
+      var _state$selection3 = state.selection,
+        $from = _state$selection3.$from,
+        empty = _state$selection3.empty;
+      var marks = state.schema.marks;
+      if (empty) {
+        return !!marks[mark].isInSet(state.storedMarks || $from.marks());
+      }
+      return anyMarkActive(state, marks[mark]);
+    }
+    return false;
+  });
+  return activeMarkTypes.length > 0;
+};
+export var checkFormattingIsPresent = function checkFormattingIsPresent(state) {
+  return marksArePresent(state) || blockStylingIsPresent(state);
+};
+export var compareItemsArrays = function compareItemsArrays(items, prevItems) {
+  return items && items.filter(function (item) {
+    return !prevItems.includes(item);
+  });
+};
+export var isArrayContainsContent = function isArrayContainsContent(items, content) {
+  return items.filter(function (item) {
+    return item.content === content;
+  }).length > 0;
+};

package/dist/esm/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/editor-plugin-text-formatting",
+	"version": "0.1.0",
+	"sideEffects": false
+}

package/dist/types/actions.d.ts

@@ -0,0 +1,22 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Command, InputMethodBasic } from '@atlaskit/editor-common/types';
+type ToggleMarkCommand = () => Command;
+export type ToggleMarkWithAnalyticsCommand = (analyticsMetadata: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+type ToggleMarkWithAnalyticsFactory = (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => ToggleMarkWithAnalyticsCommand;
+export declare const toggleEm: ToggleMarkCommand;
+export declare const toggleEmWithAnalytics: ToggleMarkWithAnalyticsFactory;
+export declare const toggleStrike: ToggleMarkCommand;
+export declare const toggleStrikeWithAnalytics: ToggleMarkWithAnalyticsFactory;
+export declare const toggleStrong: ToggleMarkCommand;
+export declare const toggleStrongWithAnalytics: ToggleMarkWithAnalyticsFactory;
+export declare const toggleUnderline: ToggleMarkCommand;
+export declare const toggleUnderlineWithAnalytics: ToggleMarkWithAnalyticsFactory;
+export declare const toggleSuperscript: ToggleMarkCommand;
+export declare const toggleSuperscriptWithAnalytics: ToggleMarkWithAnalyticsFactory;
+export declare const toggleSubscript: ToggleMarkCommand;
+export declare const toggleSubscriptWithAnalytics: ToggleMarkWithAnalyticsFactory;
+export declare const toggleCode: ToggleMarkCommand;
+export declare const toggleCodeWithAnalytics: ToggleMarkWithAnalyticsFactory;
+export {};

package/dist/types/commands/clear-formatting.d.ts

@@ -0,0 +1,6 @@
+import type { EditorAnalyticsAPI, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command } from '@atlaskit/editor-common/types';
+export declare const FORMATTING_NODE_TYPES: string[];
+export declare const FORMATTING_MARK_TYPES: string[];
+export declare function clearFormattingWithAnalytics(inputMethod: INPUT_METHOD.TOOLBAR | INPUT_METHOD.SHORTCUT, editorAnalyticsAPI: EditorAnalyticsAPI | undefined): Command;
+export declare function clearFormatting(inputMethod?: INPUT_METHOD.TOOLBAR | INPUT_METHOD.SHORTCUT, editorAnalyticsAPI?: EditorAnalyticsAPI | undefined): Command;

package/dist/types/commands/text-formatting.d.ts

@@ -0,0 +1,5 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Command } from '@atlaskit/editor-common/types';
+export declare const moveRight: () => Command;
+export declare const moveLeft: () => Command;
+export declare const createInlineCodeFromTextInputWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (from: number, to: number, text: string) => Command;

package/dist/types/commands/transform-to-code.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const transformSmartCharsMentionsAndEmojis: (from: number, to: number, tr: Transaction) => void;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { textFormattingPlugin } from './plugin';
+export type { TextFormattingPlugin } from './plugin';
+export type { ToggleMarkWithAnalyticsCommand } from './actions';

package/dist/types/plugin.d.ts

@@ -0,0 +1,17 @@
+import type { NextEditorPlugin, OptionalPlugin, TextFormattingOptions } from '@atlaskit/editor-common/types';
+import type { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { ToggleMarkWithAnalyticsCommand } from './actions';
+export type TextFormattingPlugin = NextEditorPlugin<'textFormatting', {
+    pluginConfiguration: TextFormattingOptions | undefined;
+    dependencies: [OptionalPlugin<typeof analyticsPlugin>];
+    actions: {
+        toggleSuperscript: ToggleMarkWithAnalyticsCommand;
+        toggleSubscript: ToggleMarkWithAnalyticsCommand;
+        toggleStrike: ToggleMarkWithAnalyticsCommand;
+        toggleCode: ToggleMarkWithAnalyticsCommand;
+        toggleUnderline: ToggleMarkWithAnalyticsCommand;
+        toggleEm: ToggleMarkWithAnalyticsCommand;
+        toggleStrong: ToggleMarkWithAnalyticsCommand;
+    };
+}>;
+export declare const textFormattingPlugin: TextFormattingPlugin;

package/dist/types/pm-plugins/clear-formatting-keymap.d.ts

@@ -0,0 +1,4 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function keymapPlugin(editorAnalyticsAPI: EditorAnalyticsAPI | undefined): SafePlugin;
+export default keymapPlugin;

package/dist/types/pm-plugins/clear-formatting.d.ts

@@ -0,0 +1,8 @@
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export interface ClearFormattingState {
+    formattingIsPresent?: boolean;
+}
+export declare const pluginKey: PluginKey<ClearFormattingState>;
+export declare const plugin: (dispatch: Dispatch) => SafePlugin<ClearFormattingState>;

package/dist/types/pm-plugins/cursor.d.ts

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare const _default: SafePlugin<any>;
+export default _default;

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

@@ -0,0 +1,23 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+declare enum ValidAutoformatChars {
+    STRONG = "__",
+    STRIKE = "~~",
+    STRONG_MARKDOWN = "**",
+    ITALIC_MARKDOWN = "*",
+    ITALIC = "_",
+    CODE = "`"
+}
+export declare const ValidCombinations: Record<ValidAutoformatChars, string[]>;
+declare class ReverseRegexExp extends RegExp {
+    exec(str: string): RegExpExecArray | null;
+}
+export declare const strongRegex1: ReverseRegexExp;
+export declare const strongRegex2: ReverseRegexExp;
+export declare const italicRegex1: ReverseRegexExp;
+export declare const italicRegex2: ReverseRegexExp;
+export declare const strikeRegex: ReverseRegexExp;
+export declare const codeRegex: ReverseRegexExp;
+export declare function inputRulePlugin(schema: Schema, editorAnalyticsAPI: EditorAnalyticsAPI | undefined): SafePlugin | undefined;
+export default inputRulePlugin;

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

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

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

@@ -0,0 +1,7 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { TextFormattingState } from '@atlaskit/editor-common/types';
+import { pluginKey } from './plugin-key';
+export { pluginKey };
+export declare const plugin: (dispatch: Dispatch, editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => SafePlugin<TextFormattingState>;

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

@@ -0,0 +1,3 @@
+import type { TextFormattingState } from '@atlaskit/editor-common/types';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const pluginKey: PluginKey<TextFormattingState>;

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

@@ -0,0 +1,3 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+declare const _default: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => import("@atlaskit/editor-common/safe-plugin").SafePlugin<any>;
+export default _default;

package/dist/types/ui/Toolbar/constants.d.ts

@@ -0,0 +1,6 @@
+import { ToolbarSize } from '@atlaskit/editor-common/types';
+import { IconTypes } from './types';
+export declare const DefaultButtonsToolbar: IconTypes[];
+export declare const DefaultButtonsMenu: IconTypes[];
+export declare const ResponsiveCustomButtonToolbar: Record<ToolbarSize, IconTypes[]>;
+export declare const ResponsiveCustomMenu: Record<ToolbarSize, IconTypes[]>;

package/dist/types/ui/Toolbar/dropdown-menu.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MenuIconItem } from './types';
+type DropdownMenuProps = {
+    editorView: EditorView;
+    isReducedSpacing: boolean;
+    items: Array<MenuIconItem>;
+    moreButtonLabel: string;
+    hasFormattingActive: boolean;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+};
+export declare const FormattingTextDropdownMenu: React.MemoExoticComponent<({ editorView, moreButtonLabel, isReducedSpacing, items, hasFormattingActive, popupsBoundariesElement, popupsMountPoint, popupsScrollableElement, }: DropdownMenuProps) => JSX.Element>;
+export {};

package/dist/types/ui/Toolbar/hooks/clear-formatting-icon.d.ts

@@ -0,0 +1,7 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { IconHookProps, MenuIconItem } from '../types';
+interface ClearIconHookProps extends IconHookProps {
+    editorAnalyticsAPI: EditorAnalyticsAPI | undefined;
+}
+export declare const useClearIcon: ({ intl, editorState, editorAnalyticsAPI, }: ClearIconHookProps) => MenuIconItem | null;
+export {};

package/dist/types/ui/Toolbar/hooks/formatting-icons.d.ts

@@ -0,0 +1,14 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { IconHookProps, MenuIconItem } from '../types';
+import { IconTypes } from '../types';
+interface FormattingIconHookProps extends IconHookProps {
+    editorAnalyticsAPI: EditorAnalyticsAPI | undefined;
+}
+export declare const useFormattingIcons: ({ isToolbarDisabled, editorState, intl, editorAnalyticsAPI, }: FormattingIconHookProps) => Array<MenuIconItem | null>;
+type Props = {
+    editorState: EditorState;
+    iconTypeList: IconTypes[];
+};
+export declare const useHasFormattingActived: ({ editorState, iconTypeList, }: Props) => boolean;
+export {};

package/dist/types/ui/Toolbar/hooks/menu-state.d.ts

@@ -0,0 +1 @@
+export declare const useMenuState: () => readonly [boolean, () => void, () => void];

package/dist/types/ui/Toolbar/hooks/responsive-toolbar-buttons.d.ts

@@ -0,0 +1,20 @@
+import type { ToolbarSize } from '@atlaskit/editor-common/types';
+import type { MenuIconItem } from '../types';
+export declare const useResponsiveIconTypeButtons: ({ toolbarSize, responsivenessEnabled, }: {
+    toolbarSize: ToolbarSize;
+    responsivenessEnabled: boolean;
+}) => import("../types").IconTypes[];
+export declare const useResponsiveIconTypeMenu: ({ toolbarSize, responsivenessEnabled, }: {
+    toolbarSize: ToolbarSize;
+    responsivenessEnabled: boolean;
+}) => import("../types").IconTypes[];
+type IconsPositions = {
+    dropdownItems: Array<MenuIconItem>;
+    singleItems: Array<MenuIconItem>;
+};
+export declare const useResponsiveToolbarButtons: ({ icons, toolbarSize, responsivenessEnabled, }: {
+    responsivenessEnabled: boolean;
+    toolbarSize: ToolbarSize;
+    icons: Array<MenuIconItem | null>;
+}) => IconsPositions;
+export {};

package/dist/types/ui/Toolbar/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { ToolbarSize } from '@atlaskit/editor-common/types';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export type ToolbarFormattingProps = {
+    editorView: EditorView;
+    isToolbarDisabled: boolean;
+    toolbarSize: ToolbarSize;
+    isReducedSpacing: boolean;
+    shouldUseResponsiveToolbar: boolean;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+};
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<ToolbarFormattingProps & WrappedComponentProps<"intl"> & {
+    editorState: EditorState;
+}>> & {
+    WrappedComponent: import("react").ComponentType<ToolbarFormattingProps & WrappedComponentProps<"intl"> & {
+        editorState: EditorState;
+    }>;
+};
+export default _default;

package/dist/types/ui/Toolbar/more-button.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+type MoreButtonProps = {
+    label: string;
+    isReducedSpacing: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+    'aria-expanded': React.AriaAttributes['aria-expanded'];
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
+    onKeyDown?: (event: React.KeyboardEvent) => void;
+};
+export declare const MoreButton: React.MemoExoticComponent<({ label, "aria-expanded": ariaExpanded, isReducedSpacing, isSelected, isDisabled, onClick, onKeyDown, }: MoreButtonProps) => jsx.JSX.Element>;
+export {};