@atlaskit/editor-core 188.9.0 → 188.9.5

package/dist/es2019/plugins/type-ahead/constants.js

@@ -1,9 +0,0 @@
-export const TYPE_AHEAD_DECORATION_KEY = 'typeahead_decoration_key';
-export const TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE = 'typeaheadDecoration';
-export const TYPE_AHEAD_POPUP_CONTENT_CLASS = 'fabric-editor-typeahead';
-export const TYPE_AHEAD_DECORATION_ELEMENT_ID = 'typeahaed_decoration_element_id';
-export let CloseSelectionOptions = /*#__PURE__*/function (CloseSelectionOptions) {
-  CloseSelectionOptions["BEFORE_TEXT_INSERTED"] = "BEFORE_TEXT_INSERTED";
-  CloseSelectionOptions["AFTER_TEXT_INSERTED"] = "AFTER_TEXT_INSERTED";
-  return CloseSelectionOptions;
-}({});

package/dist/es2019/plugins/type-ahead/index.js

@@ -1,3 +0,0 @@
-import { typeAheadPlugin } from './plugin';
-export default typeAheadPlugin;
-export { typeAheadPlugin };

package/dist/es2019/plugins/type-ahead/insert-utils.js

@@ -1,106 +0,0 @@
-import { TextSelection, NodeSelection } from '@atlaskit/editor-prosemirror/state';
-import { Node as PMNode, Slice, Fragment } from '@atlaskit/editor-prosemirror/model';
-import { safeInsert, normaliseNestedLayout } from '@atlaskit/editor-common/insert';
-function findInsertPoint(doc, pos, nodeToInsert) {
-  const $pos = doc.resolve(pos);
-  const createInsertPosition = (from, to) => ({
-    from,
-    to: to || from
-  });
-
-  // Search for a valid position for nodeToInsert in progressively higher levels
-  for (let level = $pos.depth; level >= 0; level--) {
-    const nodeAtLevel = $pos.node(level);
-
-    // Try to replace the empty paragraph in the level above
-    // Scenario:
-    //   doc(
-    //     table(
-    //       row(
-    //         cell(
-    //           p('{<>}'),
-    //         ),
-    //       )
-    //     )
-    //   )
-    const levelAbove = Math.max(level - 1, 0);
-    const parentNode = $pos.node(levelAbove);
-    // Special case: when this is true, the 'to' position should be the end
-    // of the empty paragraph
-    const isNodeAtLevelEmptyParagraph = nodeAtLevel.type.name === 'paragraph' && nodeAtLevel.content.size === 0;
-    const indexAtLevelAbove = $pos.index(levelAbove);
-    const canReplaceNodeAtLevelAbove = parentNode.canReplaceWith(indexAtLevelAbove, indexAtLevelAbove, nodeToInsert.type);
-    if (isNodeAtLevelEmptyParagraph && canReplaceNodeAtLevelAbove) {
-      const from = $pos.posAtIndex(indexAtLevelAbove, levelAbove);
-      return createInsertPosition(from, from + nodeAtLevel.nodeSize);
-    }
-
-    // Try to insert this node right after the node in the level above
-    // Scenario:
-    //   doc(
-    //     panel(
-    //       p('{<>}'),
-    //     )
-    //   )
-    const indexAfterAtLevelAbove = $pos.indexAfter(levelAbove);
-    const canInsertNodeAtLevelAbove = parentNode.canReplaceWith(indexAfterAtLevelAbove, indexAfterAtLevelAbove, nodeToInsert.type);
-    if (canInsertNodeAtLevelAbove) {
-      return createInsertPosition($pos.posAtIndex(indexAfterAtLevelAbove, levelAbove));
-    }
-  }
-  return createInsertPosition(0);
-}
-export const insertBlockNode = ({
-  node,
-  tr,
-  position
-}) => {
-  const {
-    start,
-    end
-  } = position;
-  if (node.isText) {
-    return tr.replaceWith(start, end, node);
-  }
-  if (node.isBlock) {
-    tr.delete(start, end);
-    const mappedStart = tr.mapping.map(start);
-    const nodeNormalized = normaliseNestedLayout(tr, node);
-
-    // Handle edge cases for hr and mediaSingle
-    const inserted = safeInsert(nodeNormalized, mappedStart)(tr);
-    if (inserted) {
-      return tr;
-    }
-    const sliceInserted = Slice.maxOpen(Fragment.from(nodeNormalized));
-    const {
-      from,
-      to
-    } = findInsertPoint(tr.doc, mappedStart, nodeNormalized);
-    tr.replaceWith(from, to, node);
-    const openPosition = Math.min(from + (node.isAtom ? node.nodeSize : sliceInserted.openStart), tr.doc.content.size);
-    const FORWARD_DIRECTION = 1;
-    const nextSelection = TextSelection.findFrom(tr.doc.resolve(openPosition), FORWARD_DIRECTION, true);
-    if (nextSelection) {
-      return tr.setSelection(nextSelection);
-    }
-  }
-  return tr;
-};
-export const insertInlineNodeOrFragment = ({
-  maybeFragment,
-  tr,
-  position,
-  selectInlineNode
-}) => {
-  const {
-    start,
-    end
-  } = position;
-  const fragment = maybeFragment instanceof PMNode ? Fragment.from(maybeFragment) : maybeFragment;
-  tr.replaceWith(start, end, fragment);
-  if (selectInlineNode) {
-    return tr.setSelection(NodeSelection.create(tr.doc, start));
-  }
-  return tr.setSelection(TextSelection.near(tr.doc.resolve(start + fragment.size)));
-};

package/dist/es2019/plugins/type-ahead/messages.js

@@ -1,73 +0,0 @@
-import { defineMessages } from 'react-intl-next';
-export const typeAheadListMessages = defineMessages({
-  typeAheadPopupLabel: {
-    id: 'fabric.editor.typeAhead.popupLabel',
-    defaultMessage: 'Typeahead results',
-    description: 'the result of a typeahead, similar to autocomplete results+'
-  },
-  quickInsertPopupLabel: {
-    id: 'fabric.editor.typeAhead.quickInsertPopupLabel',
-    defaultMessage: 'Shortcuts for inserts and formatting',
-    description: 'the result of a quick insert typeahead, similar to autocomplete results+'
-  },
-  quickInsertInputLabel: {
-    id: 'fabric.editor.typeAhead.quickInsertInputLabel',
-    defaultMessage: 'Begin typing to search or filter shortcut options',
-    description: 'assisitve text for typeahed input field'
-  },
-  emojiPopupLabel: {
-    id: 'fabric.editor.typeahead.emojiPopupLabel',
-    defaultMessage: 'Emoji shortcuts',
-    description: 'the result of a emoji typeahead, similar to autocomplete results+'
-  },
-  emojiInputLabel: {
-    id: 'fabric.editor.typeahead.emojiInputLabel',
-    defaultMessage: 'Begin typing to search or filter emoji options',
-    description: 'assisitve text for typeahed input field'
-  },
-  mentionPopupLabel: {
-    id: 'fabric.editor.typeahead.mentionPopupLabel',
-    defaultMessage: 'Users you can tag',
-    description: 'the aria label of a mention typeahead popup'
-  },
-  mentionInputLabel: {
-    id: 'fabric.editor.typeahead.mentionInputLabel',
-    defaultMessage: 'Begin typing to search for users to tag',
-    description: 'assisitve text for typeahed input field'
-  },
-  metionListItemLabel: {
-    id: 'fabric.editor.typeahead.metionListItemLabel',
-    defaultMessage: 'User {name} @{shortName}',
-    description: 'assistive text for user mention items username and nickname'
-  },
-  emojiListItemLabel: {
-    id: 'fabric.editor.typeahead.emojiListItemLabel',
-    defaultMessage: 'Emoji {name} Text Shortcut {shortcut}',
-    description: 'assistive text for emoji name and shortcut'
-  },
-  inputQueryAssistiveLabel: {
-    id: 'fabric.editor.inputQueryAssistiveTxt',
-    defaultMessage: 'When autocomplete results are available use up and down arrows to review and enter to select. Touch device users, explore by touch or with swipe gestures.',
-    description: 'Assistive text to the user when using typeahead shortcut'
-  },
-  searchResultsLabel: {
-    id: 'fabric.editor.searchResults',
-    defaultMessage: '{itemsLength, plural, one {# search result} other {# search results}} available',
-    description: 'Assistive text to the user when using typeahead shortcut and it preceeds with a number - Ex: 10 search results available'
-  },
-  noSearchResultsLabel: {
-    id: 'fabric.editor.noSearchResults',
-    defaultMessage: 'No search results',
-    description: 'Assistive text to the user when using typeahead shortcut'
-  },
-  descriptionLabel: {
-    id: 'fabric.editor.description',
-    defaultMessage: 'Description',
-    description: 'Description'
-  },
-  shortcutLabel: {
-    id: 'fabric.editor.shortcut',
-    defaultMessage: 'Text shortcut',
-    description: 'Text shortcut'
-  }
-});

package/dist/es2019/plugins/type-ahead/plugin.js

@@ -1,381 +0,0 @@
-/**
- *
- * Revamped typeahead using decorations instead of the `typeAheadQuery` mark
- *
- * https://product-fabric.atlassian.net/wiki/spaces/E/pages/2992177582/Technical+TypeAhead+Data+Flow
- *
- *
- */
-import React from 'react';
-import { typeAheadQuery } from '@atlaskit/adf-schema';
-import { ACTION, ACTION_SUBJECT, EVENT_TYPE, fireAnalyticsEvent, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
-import { WithPluginState } from '@atlaskit/editor-common/with-plugin-state';
-import { insertTypeAheadItem } from './commands/insert-type-ahead-item';
-import { updateSelectedIndex } from './commands/update-selected-index';
-import { inputRulePlugin } from './pm-plugins/input-rules';
-import { createPlugin as createInsertItemPlugin } from './pm-plugins/insert-item-plugin';
-import { pluginKey as typeAheadPluginKey } from './pm-plugins/key';
-import { createPlugin } from './pm-plugins/main';
-import { StatsModifier } from './stats-modifier';
-import { closeTypeAhead } from './transforms/close-type-ahead';
-import { openTypeAheadAtCursor } from './transforms/open-typeahead-at-cursor';
-import { useItemInsert } from './ui/hooks/use-item-insert';
-import { TypeAheadPopup } from './ui/TypeAheadPopup';
-import { findHandler, getPluginState, getTypeAheadHandler, getTypeAheadQuery, isTypeAheadAllowed, isTypeAheadOpen } from './utils';
-const TypeAheadMenu = /*#__PURE__*/React.memo(({
-  editorView,
-  popupMountRef,
-  typeAheadState,
-  fireAnalyticsCallback
-}) => {
-  var _popupMountRef$curren, _popupMountRef$curren2, _popupMountRef$curren3;
-  const isOpen = typeAheadState.decorationSet.find().length > 0;
-  const {
-    triggerHandler,
-    items,
-    selectedIndex,
-    decorationElement,
-    decorationSet,
-    query
-  } = typeAheadState;
-  const [onItemInsert, onTextInsert, onItemMatch] = useItemInsert(triggerHandler, editorView, items);
-  const setSelectedItem = React.useCallback(({
-    index: nextIndex
-  }) => {
-    queueMicrotask(() => {
-      updateSelectedIndex(nextIndex)(editorView.state, editorView.dispatch);
-    });
-  }, [editorView]);
-  const insertItem = React.useCallback((mode = SelectItemMode.SELECTED, index) => {
-    queueMicrotask(() => {
-      onItemInsert({
-        mode,
-        index,
-        query
-      });
-    });
-  }, [onItemInsert, query]);
-  const cancel = React.useCallback(({
-    setSelectionAt,
-    addPrefixTrigger,
-    forceFocusOnEditor
-  }) => {
-    const fullQuery = addPrefixTrigger ? `${triggerHandler === null || triggerHandler === void 0 ? void 0 : triggerHandler.trigger}${query}` : query;
-    onTextInsert({
-      forceFocusOnEditor,
-      setSelectionAt,
-      text: fullQuery
-    });
-  }, [triggerHandler, onTextInsert, query]);
-  React.useEffect(() => {
-    if (!isOpen || !query) {
-      return;
-    }
-    const isLastCharSpace = query[query.length - 1] === ' ';
-    if (!isLastCharSpace) {
-      return;
-    }
-    const result = onItemMatch({
-      mode: SelectItemMode.SPACE,
-      query: query.trim()
-    });
-    if (!result) {
-      return;
-    }
-  }, [isOpen, query, onItemMatch]);
-  if (!isOpen || !triggerHandler || !(decorationElement instanceof HTMLElement) || items.length === 0) {
-    return null;
-  }
-  return /*#__PURE__*/React.createElement(TypeAheadPopup, {
-    editorView: editorView,
-    popupsMountPoint: (_popupMountRef$curren = popupMountRef.current) === null || _popupMountRef$curren === void 0 ? void 0 : _popupMountRef$curren.popupsMountPoint,
-    popupsBoundariesElement: (_popupMountRef$curren2 = popupMountRef.current) === null || _popupMountRef$curren2 === void 0 ? void 0 : _popupMountRef$curren2.popupsBoundariesElement,
-    popupsScrollableElement: (_popupMountRef$curren3 = popupMountRef.current) === null || _popupMountRef$curren3 === void 0 ? void 0 : _popupMountRef$curren3.popupsScrollableElement,
-    anchorElement: decorationElement,
-    triggerHandler: triggerHandler,
-    fireAnalyticsCallback: fireAnalyticsCallback,
-    items: items,
-    selectedIndex: selectedIndex,
-    setSelectedItem: setSelectedItem,
-    onItemInsert: insertItem,
-    decorationSet: decorationSet,
-    isEmptyQuery: !query,
-    cancel: cancel
-  });
-});
-const createOpenAtTransaction = editorAnalyticsAPI => props => tr => {
-  const {
-    triggerHandler,
-    inputMethod
-  } = props;
-  openTypeAheadAtCursor({
-    triggerHandler,
-    inputMethod
-  })({
-    tr
-  });
-  editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
-    action: ACTION.INVOKED,
-    actionSubject: ACTION_SUBJECT.TYPEAHEAD,
-    actionSubjectId: triggerHandler.id,
-    attributes: {
-      inputMethod
-    },
-    eventType: EVENT_TYPE.UI
-  })(tr);
-  return true;
-};
-const createOpenTypeAhead = (editorViewRef, editorAnalyticsAPI) => props => {
-  if (!editorViewRef.current) {
-    return false;
-  }
-  const {
-    current: view
-  } = editorViewRef;
-  const {
-    tr
-  } = view.state;
-  createOpenAtTransaction(editorAnalyticsAPI)(props)(tr);
-  view.dispatch(tr);
-  return true;
-};
-const createInsertTypeAheadItem = editorViewRef => props => {
-  if (!editorViewRef.current) {
-    return false;
-  }
-  const {
-    current: view
-  } = editorViewRef;
-  const {
-    triggerHandler,
-    contentItem,
-    query,
-    sourceListItem,
-    mode
-  } = props;
-  insertTypeAheadItem(view)({
-    handler: triggerHandler,
-    item: contentItem,
-    mode: mode || SelectItemMode.SELECTED,
-    query,
-    sourceListItem
-  });
-  return true;
-};
-const createFindHandlerByTrigger = editorViewRef => trigger => {
-  if (!editorViewRef.current) {
-    return null;
-  }
-  const {
-    current: view
-  } = editorViewRef;
-  return findHandler(trigger, view.state);
-};
-const createCloseTypeAhead = editorViewRef => options => {
-  if (!editorViewRef.current) {
-    return false;
-  }
-  const {
-    current: view
-  } = editorViewRef;
-  const currentQuery = getTypeAheadQuery(view.state) || '';
-  const {
-    state
-  } = view;
-  let tr = state.tr;
-  if (options.attachCommand) {
-    const fakeDispatch = customTr => {
-      tr = customTr;
-    };
-    options.attachCommand(state, fakeDispatch);
-  }
-  closeTypeAhead(tr);
-  if (options.insertCurrentQueryAsRawText && currentQuery && currentQuery.length > 0) {
-    const handler = getTypeAheadHandler(state);
-    if (!handler) {
-      return false;
-    }
-    const text = handler.trigger.concat(currentQuery);
-    tr.replaceSelectionWith(state.schema.text(text));
-  }
-  view.dispatch(tr);
-  if (!view.hasFocus()) {
-    view.focus();
-  }
-  return true;
-};
-
-/**
- *
- * Revamped typeahead using decorations instead of the `typeAheadQuery` mark
- *
- * https://product-fabric.atlassian.net/wiki/spaces/E/pages/2992177582/Technical+TypeAhead+Data+Flow
- *
- *
- */
-export const typeAheadPlugin = ({
-  config: options,
-  api
-}) => {
-  var _api$analytics, _api$analytics2;
-  const fireAnalyticsCallback = fireAnalyticsEvent(options === null || options === void 0 ? void 0 : options.createAnalyticsEvent);
-  const popupMountRef = {
-    current: null
-  };
-  const editorViewRef = {
-    current: null
-  };
-  return {
-    name: 'typeAhead',
-    marks() {
-      // We need to keep this to make sure
-      // All documents with typeahead marks will be loaded normally
-      return [{
-        name: 'typeAheadQuery',
-        mark: typeAheadQuery
-      }];
-    },
-    pmPlugins(typeAhead = []) {
-      return [{
-        name: 'typeAhead',
-        plugin: ({
-          dispatch,
-          getIntl
-        }) => createPlugin({
-          getIntl,
-          popupMountRef,
-          reactDispatch: dispatch,
-          typeAheadHandlers: typeAhead,
-          createAnalyticsEvent: options === null || options === void 0 ? void 0 : options.createAnalyticsEvent
-        })
-      }, {
-        name: 'typeAheadEditorViewRef',
-        plugin: () => {
-          return new SafePlugin({
-            view(view) {
-              editorViewRef.current = view;
-              return {
-                destroy() {
-                  editorViewRef.current = null;
-                }
-              };
-            }
-          });
-        }
-      }, {
-        name: 'typeAheadInsertItem',
-        plugin: createInsertItemPlugin
-      }, {
-        name: 'typeAheadInputRule',
-        plugin: ({
-          schema,
-          featureFlags
-        }) => inputRulePlugin(schema, typeAhead, featureFlags)
-      }];
-    },
-    getSharedState(editorState) {
-      if (!editorState) {
-        return {
-          query: '',
-          isOpen: false,
-          isAllowed: false,
-          currentHandler: undefined
-        };
-      }
-      const isOpen = isTypeAheadOpen(editorState);
-      return {
-        query: getTypeAheadQuery(editorState) || '',
-        currentHandler: getTypeAheadHandler(editorState),
-        isOpen,
-        isAllowed: !isOpen
-      };
-    },
-    actions: {
-      isOpen: isTypeAheadOpen,
-      isAllowed: isTypeAheadAllowed,
-      open: createOpenTypeAhead(editorViewRef, api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions),
-      openAtTransaction: createOpenAtTransaction(api === null || api === void 0 ? void 0 : (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions),
-      findHandlerByTrigger: createFindHandlerByTrigger(editorViewRef),
-      insert: createInsertTypeAheadItem(editorViewRef),
-      close: createCloseTypeAhead(editorViewRef)
-    },
-    contentComponent({
-      editorView,
-      containerElement,
-      popupsMountPoint,
-      popupsBoundariesElement,
-      popupsScrollableElement,
-      wrapperElement
-    }) {
-      popupMountRef.current = {
-        popupsMountPoint: popupsMountPoint || wrapperElement || undefined,
-        popupsBoundariesElement,
-        popupsScrollableElement: popupsScrollableElement || containerElement || undefined
-      };
-      return /*#__PURE__*/React.createElement(WithPluginState, {
-        plugins: {
-          typeAheadState: typeAheadPluginKey
-        },
-        render: ({
-          typeAheadState
-        }) => {
-          if (!typeAheadState) {
-            return null;
-          }
-          return /*#__PURE__*/React.createElement(TypeAheadMenu, {
-            editorView: editorView,
-            popupMountRef: popupMountRef,
-            typeAheadState: typeAheadState,
-            fireAnalyticsCallback: fireAnalyticsCallback
-          });
-        }
-      });
-    },
-    onEditorViewStateUpdated({
-      originalTransaction,
-      oldEditorState,
-      newEditorState
-    }) {
-      const oldPluginState = getPluginState(oldEditorState);
-      const newPluginState = getPluginState(newEditorState);
-      if (!oldPluginState || !newPluginState) {
-        return;
-      }
-      const {
-        triggerHandler: oldTriggerHandler
-      } = oldPluginState;
-      const {
-        triggerHandler: newTriggerHandler
-      } = newPluginState;
-      const isANewHandler = oldTriggerHandler !== newTriggerHandler;
-      if (oldTriggerHandler !== null && oldTriggerHandler !== void 0 && oldTriggerHandler.dismiss && isANewHandler) {
-        const typeAheadMessage = originalTransaction.getMeta(typeAheadPluginKey);
-        const wasItemInserted = typeAheadMessage && typeAheadMessage.action === 'INSERT_RAW_QUERY';
-        oldTriggerHandler.dismiss({
-          editorState: newEditorState,
-          query: oldPluginState.query,
-          stats: (oldPluginState.stats || new StatsModifier()).serialize(),
-          wasItemInserted
-        });
-      }
-      if (newTriggerHandler !== null && newTriggerHandler !== void 0 && newTriggerHandler.onOpen && isANewHandler) {
-        newTriggerHandler.onOpen(newEditorState);
-      }
-      if (newTriggerHandler && isANewHandler && options !== null && options !== void 0 && options.createAnalyticsEvent) {
-        fireAnalyticsCallback({
-          payload: {
-            action: ACTION.INVOKED,
-            actionSubject: ACTION_SUBJECT.TYPEAHEAD,
-            actionSubjectId: newTriggerHandler.id || 'not_set',
-            attributes: {
-              inputMethod: newPluginState.inputMethod || INPUT_METHOD.KEYBOARD
-            },
-            eventType: EVENT_TYPE.UI
-          }
-        });
-      }
-    }
-  };
-};

package/dist/es2019/plugins/type-ahead/pm-plugins/actions.js

@@ -1,10 +0,0 @@
-export let ACTIONS = /*#__PURE__*/function (ACTIONS) {
-  ACTIONS["OPEN_TYPEAHEAD_AT_CURSOR"] = "OPEN_TYPEAHEAD_AT_CURSOR";
-  ACTIONS["CLOSE_TYPE_AHEAD"] = "CLOSE_TYPE_AHEAD";
-  ACTIONS["CHANGE_QUERY"] = "CHANGE_QUERY";
-  ACTIONS["INSERT_ITEM"] = "INSERT_ITEM";
-  ACTIONS["INSERT_RAW_QUERY"] = "INSERT_RAW_QUERY";
-  ACTIONS["UPDATE_LIST_ITEMS"] = "UPDATE_LIST_ITEMS";
-  ACTIONS["UPDATE_SELECTED_INDEX"] = "UPDATE_SELECTED_INDEX";
-  return ACTIONS;
-}({});