@atlaskit/editor-core 187.17.6 → 187.18.1

package/dist/es2019/plugins/text-formatting/pm-plugins/clear-formatting-keymap.js

@@ -1,10 +0,0 @@
-import { keymap } from '@atlaskit/editor-prosemirror/keymap';
-import * as keymaps from '@atlaskit/editor-common/keymaps';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { clearFormattingWithAnalytics } from '../commands/clear-formatting';
-export function keymapPlugin(editorAnalyticsAPI) {
-  const list = {};
-  keymaps.bindKeymapWithCommand(keymaps.clearFormatting.common, clearFormattingWithAnalytics(INPUT_METHOD.SHORTCUT, editorAnalyticsAPI), list);
-  return keymap(list);
-}
-export default keymapPlugin;

package/dist/es2019/plugins/text-formatting/pm-plugins/clear-formatting.js

@@ -1,26 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { PluginKey } from '@atlaskit/editor-prosemirror/state';
-import { checkFormattingIsPresent } from '../utils';
-export const pluginKey = new PluginKey('clearFormattingPlugin');
-export const plugin = dispatch => new SafePlugin({
-  state: {
-    init(_config, state) {
-      return {
-        formattingIsPresent: checkFormattingIsPresent(state)
-      };
-    },
-    apply(_tr, pluginState, _oldState, newState) {
-      const formattingIsPresent = checkFormattingIsPresent(newState);
-      if (formattingIsPresent !== pluginState.formattingIsPresent) {
-        dispatch(pluginKey, {
-          formattingIsPresent
-        });
-        return {
-          formattingIsPresent
-        };
-      }
-      return pluginState;
-    }
-  },
-  key: pluginKey
-});

package/dist/es2019/plugins/text-formatting/pm-plugins/cursor.js

@@ -1,52 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-export default new SafePlugin({
-  props: {
-    handleClick(view, clickPos, event) {
-      // Don't apply in Edge as per ED-4546
-      if (navigator && /Edge\/\d/.test(navigator.userAgent)) {
-        return false;
-      }
-
-      // @see ED-6231
-      if (clickPos > view.state.doc.content.size) {
-        return false;
-      }
-      const {
-        code
-      } = view.state.schema.marks;
-      const {
-        paragraph
-      } = view.state.schema.nodes;
-      const $click = view.state.doc.resolve(clickPos);
-      const clickWasAtEdgeOfATextNode = ($click.nodeBefore ? $click.nodeBefore.isInline : $click.nodeAfter) && ($click.nodeAfter ? $click.nodeAfter.isInline : $click.nodeBefore) && $click.textOffset === 0;
-      const clickWasNearACodeMark = code && ($click.nodeBefore && code.isInSet($click.nodeBefore.marks) || $click.nodeAfter && code.isInSet($click.nodeAfter.marks));
-
-      // Find the starting position of the clicked dom-element
-      // TODO: Remove calls to private API
-      const clickedDOMElementPosition = event.target && event.target instanceof Node && view.posAtDOM(event.target);
-      const clickNode = view.state.doc.nodeAt(clickPos);
-      const clickWasAtTextNode = !!(clickNode && clickNode.isText);
-      const clickWasAtEndOfAParagraphNode = $click.parent.type === paragraph && $click.textOffset === 0 && $click.nodeAfter === null;
-      if (clickWasAtEdgeOfATextNode && clickWasNearACodeMark && clickedDOMElementPosition && (
-      // if click did not occur at a text node or end of paragraph, then
-      // it was at a directly adjacent non-text node, so we skip this manual
-      // text selection logic to preserve that non-text node's selection
-      clickWasAtTextNode || clickWasAtEndOfAParagraphNode)) {
-        const clickWasInsideNodeDOM = event.target.parentNode === view.domAtPos(clickedDOMElementPosition).node && code.isInSet(view.state.doc.resolve(clickedDOMElementPosition).nodeAfter.marks);
-        const nodeNextToClick = $click.nodeBefore && code.isInSet($click.nodeBefore.marks) ? $click.nodeAfter : $click.nodeBefore;
-
-        // Need to set the selection here to allow clicking between [code('text'),{<>},emoji()]
-        const tr = view.state.tr.setSelection(TextSelection.near($click));
-        if (clickWasInsideNodeDOM) {
-          tr.setStoredMarks([code.create()]);
-        } else {
-          tr.setStoredMarks(nodeNextToClick ? nodeNextToClick.marks : []);
-        }
-        view.dispatch(tr);
-        return true;
-      }
-      return false;
-    }
-  }
-});

package/dist/es2019/plugins/text-formatting/pm-plugins/input-rule.js

@@ -1,244 +0,0 @@
-import { createRule, createPlugin, leafNodeReplacementCharacter } from '@atlaskit/prosemirror-input-rules';
-import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { transformSmartCharsMentionsAndEmojis } from '@atlaskit/editor-common/mark';
-import { inputRuleWithAnalytics } from '@atlaskit/editor-common/utils';
-var ValidAutoformatChars = /*#__PURE__*/function (ValidAutoformatChars) {
-  ValidAutoformatChars["STRONG"] = "__";
-  ValidAutoformatChars["STRIKE"] = "~~";
-  ValidAutoformatChars["STRONG_MARKDOWN"] = "**";
-  ValidAutoformatChars["ITALIC_MARKDOWN"] = "*";
-  ValidAutoformatChars["ITALIC"] = "_";
-  ValidAutoformatChars["CODE"] = "`";
-  return ValidAutoformatChars;
-}(ValidAutoformatChars || {});
-export const ValidCombinations = {
-  [ValidAutoformatChars.STRIKE]: [
-  // e.g: _~~lol~~_
-  ValidAutoformatChars.ITALIC,
-  // e.g: __~~lol~~__
-  ValidAutoformatChars.STRONG,
-  // e.g: **~~lol~~**
-  ValidAutoformatChars.STRONG_MARKDOWN,
-  // e.g: *~~lol~~*
-  ValidAutoformatChars.ITALIC_MARKDOWN],
-  [ValidAutoformatChars.STRONG]: [
-  // e.g: ~~__lol__~~
-  ValidAutoformatChars.STRIKE,
-  // e.g: *__lol__*
-  ValidAutoformatChars.ITALIC_MARKDOWN],
-  [ValidAutoformatChars.STRONG_MARKDOWN]: [
-  // e.g: _**lol**_
-  ValidAutoformatChars.ITALIC,
-  // e.g: ~~**lol**~~
-  ValidAutoformatChars.STRIKE],
-  [ValidAutoformatChars.ITALIC_MARKDOWN]: [
-  // e.g: ~~*lol*~~
-  ValidAutoformatChars.STRIKE,
-  // e.g: __*lol*__
-  ValidAutoformatChars.STRONG],
-  [ValidAutoformatChars.ITALIC]: [
-  // e.g: ~~_lol_~~
-  ValidAutoformatChars.STRIKE,
-  // e.g: **_lol_**
-  ValidAutoformatChars.STRONG_MARKDOWN],
-  [ValidAutoformatChars.CODE]: [
-  // e.g: loko (`some code`
-  '( ']
-};
-function addMark(markType, schema, char) {
-  return (state, match, start, end) => {
-    var _schema$marks, _schema$marks$code;
-    const {
-      doc,
-      schema,
-      tr
-    } = state;
-    const textPrefix = state.doc.textBetween(start, start + char.length);
-
-    // fixes the following case: my `*name` is *
-    // expected result: should ignore special characters inside "code"
-    if (textPrefix !== char || schema !== null && schema !== void 0 && (_schema$marks = schema.marks) !== null && _schema$marks !== void 0 && (_schema$marks$code = _schema$marks.code) !== null && _schema$marks$code !== void 0 && _schema$marks$code.isInSet(doc.resolve(start + 1).marks())) {
-      return null;
-    }
-
-    // Prevent autoformatting across hardbreaks
-    let containsHardBreak;
-    doc.nodesBetween(start, end, node => {
-      if (node.type === schema.nodes.hardBreak) {
-        containsHardBreak = true;
-        return false;
-      }
-      return !containsHardBreak;
-    });
-    if (containsHardBreak) {
-      return null;
-    }
-
-    // fixes autoformatting in heading nodes: # Heading *bold*
-    // expected result: should not autoformat *bold*; <h1>Heading *bold*</h1>
-    const startPosResolved = doc.resolve(start);
-    const endPosResolved = doc.resolve(end);
-    if (startPosResolved.sameParent(endPosResolved) && !startPosResolved.parent.type.allowsMarkType(markType)) {
-      return null;
-    }
-    if (markType.name === 'code') {
-      transformSmartCharsMentionsAndEmojis(tr.mapping.map(start), tr.mapping.map(end), tr);
-    }
-    const mappedStart = tr.mapping.map(start);
-    const mappedEnd = tr.mapping.map(end);
-    tr.addMark(mappedStart, mappedEnd, markType.create());
-    const textSuffix = tr.doc.textBetween(mappedEnd - char.length, mappedEnd);
-    if (textSuffix === char) {
-      tr.delete(mappedEnd - char.length, mappedEnd);
-    }
-    if (textPrefix === char) {
-      tr.delete(mappedStart, mappedStart + char.length);
-    }
-    return tr.removeStoredMark(markType);
-  };
-}
-class ReverseRegexExp extends RegExp {
-  exec(str) {
-    if (!str) {
-      return null;
-    }
-    const reverseStr = [...str].reverse().join('');
-    const result = super.exec(reverseStr);
-    if (!result) {
-      return null;
-    }
-    for (let i = 0; i < result.length; i++) {
-      if (result[i] && typeof result[i] === 'string') {
-        result[i] = [...result[i]].reverse().join('');
-      }
-    }
-    if (result.input && typeof result.input === 'string') {
-      result.input = [...result.input].reverse().join('');
-    }
-    if (result.input && result[0]) {
-      result.index = result.input.length - result[0].length;
-    }
-    return result;
-  }
-}
-const buildRegex = char => {
-  const escapedChar = char.replace(/(\W)/g, '\\$1');
-  const combinations = ValidCombinations[char].map(c => c.replace(/(\W)/g, '\\$1')).join('|');
-
-  // Single X - https://regex101.com/r/McT3yq/14/
-  // Double X - https://regex101.com/r/pQUgjx/1/
-  const baseRegex = '^X(?=[^X\\s]).*?[^\\sX]X(?=[\\sOBJECT_REPLACEMENT_CHARACTER]COMBINATIONS|$)'.replace('OBJECT_REPLACEMENT_CHARACTER', leafNodeReplacementCharacter).replace('COMBINATIONS', combinations ? `|${combinations}` : '');
-  const replacedRegex = String.prototype.hasOwnProperty('replaceAll') ? baseRegex.replaceAll('X', escapedChar) : baseRegex.replace(/X/g, escapedChar);
-  return new ReverseRegexExp(replacedRegex);
-};
-export const strongRegex1 = buildRegex(ValidAutoformatChars.STRONG);
-export const strongRegex2 = buildRegex(ValidAutoformatChars.STRONG_MARKDOWN);
-export const italicRegex1 = buildRegex(ValidAutoformatChars.ITALIC);
-export const italicRegex2 = buildRegex(ValidAutoformatChars.ITALIC_MARKDOWN);
-export const strikeRegex = buildRegex(ValidAutoformatChars.STRIKE);
-export const codeRegex = buildRegex(ValidAutoformatChars.CODE);
-
-/**
- * Create input rules for strong mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getStrongInputRules(schema, editorAnalyticsAPI) {
-  const ruleWithStrongAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_STRONG,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  // **string** or __strong__ should bold the text
-  const doubleUnderscoreRule = createRule(strongRegex1, addMark(schema.marks.strong, schema, ValidAutoformatChars.STRONG));
-  const doubleAsterixRule = createRule(strongRegex2, addMark(schema.marks.strong, schema, ValidAutoformatChars.STRONG_MARKDOWN));
-  return [ruleWithStrongAnalytics(doubleUnderscoreRule), ruleWithStrongAnalytics(doubleAsterixRule)];
-}
-
-/**
- * Create input rules for em mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getItalicInputRules(schema, editorAnalyticsAPI) {
-  const ruleWithItalicAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_ITALIC,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  const underscoreRule = createRule(italicRegex1, addMark(schema.marks.em, schema, ValidAutoformatChars.ITALIC));
-  const asterixRule = createRule(italicRegex2, addMark(schema.marks.em, schema, ValidAutoformatChars.ITALIC_MARKDOWN));
-  return [ruleWithItalicAnalytics(underscoreRule), ruleWithItalicAnalytics(asterixRule)];
-}
-
-/**
- * Create input rules for strike mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getStrikeInputRules(schema, editorAnalyticsAPI) {
-  const ruleWithStrikeAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_STRIKE,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  const doubleTildeRule = createRule(strikeRegex, addMark(schema.marks.strike, schema, ValidAutoformatChars.STRIKE));
-  return [ruleWithStrikeAnalytics(doubleTildeRule)];
-}
-
-/**
- * Create input rules for code mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getCodeInputRules(schema, editorAnalyticsAPI) {
-  const ruleWithCodeAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_CODE,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  const backTickRule = createRule(codeRegex, addMark(schema.marks.code, schema, ValidAutoformatChars.CODE));
-  return [ruleWithCodeAnalytics(backTickRule)];
-}
-export function inputRulePlugin(schema,
-// Don't remove the unused featureFlags, this gets used to test if we're properly passing them to the PM plugin
-_featureFlags, editorAnalyticsAPI) {
-  const rules = [];
-  if (schema.marks.strong) {
-    rules.push(...getStrongInputRules(schema, editorAnalyticsAPI));
-  }
-  if (schema.marks.em) {
-    rules.push(...getItalicInputRules(schema, editorAnalyticsAPI));
-  }
-  if (schema.marks.strike) {
-    rules.push(...getStrikeInputRules(schema, editorAnalyticsAPI));
-  }
-  if (schema.marks.code) {
-    rules.push(...getCodeInputRules(schema, editorAnalyticsAPI));
-  }
-  if (rules.length !== 0) {
-    return createPlugin('text-formatting', rules);
-  }
-  return;
-}
-export default inputRulePlugin;

package/dist/es2019/plugins/text-formatting/pm-plugins/keymap.js

@@ -1,43 +0,0 @@
-import * as keymaps from '@atlaskit/editor-common/keymaps';
-import { keymap } from '@atlaskit/editor-prosemirror/keymap';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { toggleStrongWithAnalytics, toggleEmWithAnalytics, toggleCodeWithAnalytics, toggleStrikeWithAnalytics, toggleSubscriptWithAnalytics, toggleSuperscriptWithAnalytics, toggleUnderlineWithAnalytics } from '../actions';
-export default function keymapPlugin(schema, editorAnalyticsAPI) {
-  const list = {};
-  if (schema.marks.strong) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleBold.common, toggleStrongWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.em) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleItalic.common, toggleEmWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.code) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleCode.common, toggleCodeWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.strike) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleStrikethrough.common, toggleStrikeWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.subsup) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleSubscript.common, toggleSubscriptWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.subsup) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleSuperscript.common, toggleSuperscriptWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.underline) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleUnderline.common, toggleUnderlineWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  return keymap(list);
-}

package/dist/es2019/plugins/text-formatting/pm-plugins/main.js

@@ -1,109 +0,0 @@
-// TODO: Ideally this should use the custom toggleMark function from @atlaskit/editor-common so we also disable the options when selecting inline nodes but it disables the marks when the selection is empty at this point in time which is undesirable
-// import { toggleMark } from '@atlaskit/editor-common/mark';
-import { toggleMark } from '@atlaskit/editor-prosemirror/commands';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import * as keymaps from '@atlaskit/editor-common/keymaps';
-import { shallowEqual } from '@atlaskit/editor-common/utils';
-import { createInlineCodeFromTextInputWithAnalytics } from '../commands/text-formatting';
-import * as commands from '../commands/text-formatting';
-import { anyMarkActive } from '@atlaskit/editor-common/mark';
-import { pluginKey } from './plugin-key';
-export { pluginKey };
-const getTextFormattingState = (editorState, editorAnalyticsAPI) => {
-  const {
-    em,
-    code,
-    strike,
-    strong,
-    subsup,
-    underline
-  } = editorState.schema.marks;
-  const state = {};
-  if (code) {
-    state.codeActive = anyMarkActive(editorState, code.create());
-    state.codeDisabled = !toggleMark(code)(editorState);
-  }
-  if (em) {
-    state.emActive = anyMarkActive(editorState, em);
-    state.emDisabled = state.codeActive ? true : !toggleMark(em)(editorState);
-  }
-  if (strike) {
-    state.strikeActive = anyMarkActive(editorState, strike);
-    state.strikeDisabled = state.codeActive ? true : !toggleMark(strike)(editorState);
-  }
-  if (strong) {
-    state.strongActive = anyMarkActive(editorState, strong);
-    state.strongDisabled = state.codeActive ? true : !toggleMark(strong)(editorState);
-  }
-  if (subsup) {
-    const subMark = subsup.create({
-      type: 'sub'
-    });
-    const supMark = subsup.create({
-      type: 'sup'
-    });
-    state.subscriptActive = anyMarkActive(editorState, subMark);
-    state.subscriptDisabled = state.codeActive ? true : !toggleMark(subsup, {
-      type: 'sub'
-    })(editorState);
-    state.superscriptActive = anyMarkActive(editorState, supMark);
-    state.superscriptDisabled = state.codeActive ? true : !toggleMark(subsup, {
-      type: 'sup'
-    })(editorState);
-  }
-  if (underline) {
-    state.underlineActive = anyMarkActive(editorState, underline);
-    state.underlineDisabled = state.codeActive ? true : !toggleMark(underline)(editorState);
-  }
-  return state;
-};
-export const plugin = (dispatch, editorAnalyticsAPI) => new SafePlugin({
-  state: {
-    init(_config, state) {
-      return getTextFormattingState(state, editorAnalyticsAPI);
-    },
-    apply(_tr, pluginState, _oldState, newState) {
-      const state = getTextFormattingState(newState, editorAnalyticsAPI);
-      if (!shallowEqual(pluginState, state)) {
-        dispatch(pluginKey, state);
-        return state;
-      }
-      return pluginState;
-    }
-  },
-  key: pluginKey,
-  props: {
-    handleKeyDown(view, event) {
-      const {
-        state,
-        dispatch
-      } = view;
-      if (event.key === keymaps.moveRight.common && !event.metaKey) {
-        return commands.moveRight()(state, dispatch);
-      } else if (event.key === keymaps.moveLeft.common && !event.metaKey) {
-        return commands.moveLeft()(state, dispatch);
-      }
-      return false;
-    },
-    handleTextInput(view, from, to, text) {
-      const {
-        state,
-        dispatch
-      } = view;
-      const {
-        schema,
-        selection: {
-          $from: {
-            parent: {
-              type: parentNodeType
-            }
-          }
-        }
-      } = state;
-      if (parentNodeType.allowsMarkType(schema.marks.code)) {
-        return createInlineCodeFromTextInputWithAnalytics(editorAnalyticsAPI)(from, to, text)(state, dispatch);
-      }
-      return false;
-    }
-  }
-});

package/dist/es2019/plugins/text-formatting/pm-plugins/plugin-key.js

@@ -1,2 +0,0 @@
-import { PluginKey } from '@atlaskit/editor-prosemirror/state';
-export const pluginKey = new PluginKey('textFormatting');

package/dist/es2019/plugins/text-formatting/pm-plugins/smart-input-rule.js

@@ -1,155 +0,0 @@
-import { Selection } from '@atlaskit/editor-prosemirror/state';
-import { createRule, createPlugin } from '@atlaskit/prosemirror-input-rules';
-import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, PUNC, SYMBOL } from '@atlaskit/editor-common/analytics';
-import { inputRuleWithAnalytics } from '@atlaskit/editor-common/utils';
-
-/**
- * Creates an InputRuleHandler that will match on a regular expression of the
- * form `(prefix, content, suffix?)`, and replace it with some given text,
- * maintaining prefix and suffix around the replacement.
- *
- * @param text text to replace with
- */
-function replaceTextUsingCaptureGroup(text) {
-  return (state, match, start, end) => {
-    const [, prefix,, suffix] = match;
-    const replacement = text + (suffix || '');
-    let {
-      tr,
-      selection: {
-        $to
-      }
-    } = state;
-    const startPos = start + (prefix || '').length;
-    const safePos = Math.min(
-    // I know it is almost impossible to have a negative value at this point.
-    // But, this is JS #trustnoone
-    Math.max(startPos, 0), end);
-    tr.replaceWith(safePos, end, state.schema.text(replacement, $to.marks()));
-    tr.setSelection(Selection.near(tr.doc.resolve(tr.selection.to)));
-    return tr;
-  };
-}
-function createReplacementRule(to, from) {
-  return createRule(from, replaceTextUsingCaptureGroup(to));
-}
-
-/**
- * Create replacement rules fiven a replacement map
- * @param replMap - Replacement map
- * @param trackingEventName - Analytics V2 tracking event name
- * @param replacementRuleWithAnalytics - Analytics GAS V3 middleware for replacement and rules.
- */
-function createReplacementRules(replMap, replacementRuleWithAnalytics) {
-  return Object.keys(replMap).map(replacement => {
-    const regex = replMap[replacement];
-    const rule = createReplacementRule(replacement, regex);
-    if (replacementRuleWithAnalytics) {
-      return replacementRuleWithAnalytics(replacement)(rule);
-    }
-    return rule;
-  });
-}
-
-// We don't agressively upgrade single quotes to smart quotes because
-// they may clash with an emoji. Only do that when we have a matching
-// single quote, or a contraction.
-function createSingleQuotesRules() {
-  return [
-  // wrapped text
-  createRule(/(\s|^)'(\S+.*\S+)'$/, (state, match, start, end) => {
-    const OPEN_SMART_QUOTE_CHAR = '‘';
-    const CLOSED_SMART_QUOTE_CHAR = '’';
-    const [, spacing, innerContent] = match;
-    // Edge case where match begins with some spacing. We need to add
-    // it back to the document
-    const openQuoteReplacement = spacing + OPEN_SMART_QUOTE_CHAR;
-    // End is not always where the closed quote is, edge case exists
-    // when there is spacing after the closed quote. We need to
-    // determine position of closed quote from the start position.
-    const positionOfClosedQuote = start + openQuoteReplacement.length + innerContent.length;
-    return state.tr.insertText(CLOSED_SMART_QUOTE_CHAR, positionOfClosedQuote, end).insertText(openQuoteReplacement, start, start + openQuoteReplacement.length);
-  }),
-  // apostrophe
-  createReplacementRule('’', /(\w+)(')(\w+)$/)];
-}
-
-/**
- * Get replacement rules related to product
- */
-function getProductRules(editorAnalyticsAPI) {
-  const productRuleWithAnalytics = product => inputRuleWithAnalytics((_, match) => ({
-    action: ACTION.SUBSTITUTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.PRODUCT_NAME,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      product,
-      originalSpelling: match[2]
-    }
-  }), editorAnalyticsAPI);
-  return createReplacementRules({
-    Atlassian: /(\s+|^)(atlassian)(\s)$/,
-    Jira: /(\s+|^)(jira|JIRA)(\s)$/,
-    Bitbucket: /(\s+|^)(bitbucket|BitBucket)(\s)$/,
-    Hipchat: /(\s+|^)(hipchat|HipChat)(\s)$/,
-    Trello: /(\s+|^)(trello)(\s)$/
-  }, productRuleWithAnalytics);
-}
-
-/**
- * Get replacement rules related to symbol
- */
-function getSymbolRules(editorAnalyticsAPI) {
-  const symbolToString = {
-    '→': SYMBOL.ARROW_RIGHT,
-    '←': SYMBOL.ARROW_LEFT,
-    '↔︎': SYMBOL.ARROW_DOUBLE
-  };
-  const symbolRuleWithAnalytics = symbol => inputRuleWithAnalytics({
-    action: ACTION.SUBSTITUTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.SYMBOL,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      symbol: symbolToString[symbol]
-    }
-  }, editorAnalyticsAPI);
-  return createReplacementRules({
-    '→': /(\s+|^)(--?>)(\s)$/,
-    '←': /(\s+|^)(<--?)(\s)$/,
-    '↔︎': /(\s+|^)(<->?)(\s)$/
-  }, symbolRuleWithAnalytics);
-}
-
-/**
- * Get replacement rules related to punctuation
- */
-function getPunctuationRules(editorAnalyticsAPI) {
-  const punctuationToString = {
-    '–': PUNC.DASH,
-    '…': PUNC.ELLIPSIS,
-    '”': PUNC.QUOTE_DOUBLE,
-    [PUNC.QUOTE_SINGLE]: PUNC.QUOTE_SINGLE
-  };
-  const punctuationRuleWithAnalytics = punctuation => inputRuleWithAnalytics({
-    action: ACTION.SUBSTITUTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.PUNC,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      punctuation: punctuationToString[punctuation]
-    }
-  }, editorAnalyticsAPI);
-  const dashEllipsisRules = createReplacementRules({
-    '–': /(\s+|^)(--)(\s)$/,
-    '…': /()(\.\.\.)$/
-  }, punctuationRuleWithAnalytics);
-  const doubleQuoteRules = createReplacementRules({
-    '“': /((?:^|[\s\{\[\(\<'"\u2018\u201C]))(")$/,
-    '”': /"$/
-  }, punctuationRuleWithAnalytics);
-  const singleQuoteRules = createSingleQuotesRules();
-  return [...dashEllipsisRules, ...doubleQuoteRules, ...singleQuoteRules.map(rule => punctuationRuleWithAnalytics(PUNC.QUOTE_SINGLE)(rule))];
-}
-export default (editorAnalyticsAPI => createPlugin('text-formatting:smart-input', [...getProductRules(editorAnalyticsAPI), ...getSymbolRules(editorAnalyticsAPI), ...getPunctuationRules(editorAnalyticsAPI)]));

package/dist/es2019/plugins/text-formatting/ui/Toolbar/constants.js

@@ -1,20 +0,0 @@
-import { ToolbarSize } from '@atlaskit/editor-common/types';
-import { IconTypes } from './types';
-export const DefaultButtonsToolbar = [IconTypes.strong, IconTypes.em];
-export const DefaultButtonsMenu = [IconTypes.underline, IconTypes.strike, IconTypes.code, IconTypes.subscript, IconTypes.superscript];
-export const ResponsiveCustomButtonToolbar = {
-  [ToolbarSize.XXL]: DefaultButtonsToolbar,
-  [ToolbarSize.XL]: DefaultButtonsToolbar,
-  [ToolbarSize.L]: DefaultButtonsToolbar,
-  [ToolbarSize.M]: [],
-  [ToolbarSize.S]: [],
-  [ToolbarSize.XXXS]: []
-};
-export const ResponsiveCustomMenu = {
-  [ToolbarSize.XXL]: DefaultButtonsMenu,
-  [ToolbarSize.XL]: DefaultButtonsMenu,
-  [ToolbarSize.L]: DefaultButtonsMenu,
-  [ToolbarSize.M]: [IconTypes.strong, IconTypes.em, ...DefaultButtonsMenu],
-  [ToolbarSize.S]: [IconTypes.strong, IconTypes.em, ...DefaultButtonsMenu],
-  [ToolbarSize.XXXS]: [IconTypes.strong, IconTypes.em, ...DefaultButtonsMenu]
-};