@atlaskit/editor-core 173.0.1 → 175.0.0

package/dist/es2019/ui/WithPluginState/index.js

@@ -1,255 +1,2 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import React from 'react';
-import PropTypes from 'prop-types';
-import { startMeasure, stopMeasure } from '@atlaskit/editor-common/utils';
-import { createDispatch } from '../../event-dispatcher';
-import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '../../plugins/analytics';
-import { analyticsEventKey } from '@atlaskit/editor-common/utils';
-import { analyticsPluginKey } from '../../plugins/analytics/plugin-key';
-import { getParticipantsCount } from '../../plugins/collab-edit/get-participants-count';
-const DEFAULT_SAMPLING_RATE = 100;
-const DEFAULT_SLOW_THRESHOLD = 4;
-
-/**
- * Wraps component in a high order component that watches state changes of given plugins
- * and passes those states to the wrapped component.
- *
- * Example:
- * <WithPluginState
- *   eventDispatcher={eventDispatcher}
- *   editorView={editorView}
- *   plugins={{
- *     hyperlink: hyperlinkPluginKey
- *   }}
- *   render={renderComponent}
- * />
- *
- * renderComponent: ({ hyperlink }) => React.Component;
- */
-export default class WithPluginState extends React.Component {
-  constructor(...args) {
-    super(...args);
-
-    _defineProperty(this, "listeners", {});
-
-    _defineProperty(this, "debounce", null);
-
-    _defineProperty(this, "notAppliedState", {});
-
-    _defineProperty(this, "isSubscribed", false);
-
-    _defineProperty(this, "callsCount", 0);
-
-    _defineProperty(this, "state", this.getPluginsStates(this.props.plugins, this.getEditorView(this.props, this.context)));
-
-    _defineProperty(this, "handlePluginStateChange", (propName, pluginName, performanceOptions, skipEqualityCheck) => pluginState => {
-      // skipEqualityCheck is being used for old plugins since they are mutating plugin state instead of creating a new one
-      if (this.state[propName] !== pluginState || skipEqualityCheck) {
-        this.updateState({
-          stateSubset: {
-            [propName]: pluginState
-          },
-          pluginName,
-          performanceOptions
-        });
-      }
-    });
-
-    _defineProperty(this, "updateState", ({
-      stateSubset,
-      pluginName,
-      performanceOptions
-    }) => {
-      this.notAppliedState = { ...this.notAppliedState,
-        ...stateSubset
-      };
-
-      if (this.debounce) {
-        window.clearTimeout(this.debounce);
-      }
-
-      const debounce = this.props.debounce !== false ? fn => window.setTimeout(fn, 0) : fn => fn();
-      this.debounce = debounce(() => {
-        const measure = `🦉${pluginName}::WithPluginState`;
-        performanceOptions.trackingEnabled && startMeasure(measure);
-        this.setState(this.notAppliedState, () => {
-          performanceOptions.trackingEnabled && stopMeasure(measure, duration => {
-            // Each WithPluginState component will fire analytics event no more than once every `samplingLimit` times
-            if (++this.callsCount % performanceOptions.samplingRate === 0 && duration > performanceOptions.slowThreshold) {
-              const editorView = this.getEditorView();
-              this.dispatchAnalyticsEvent({
-                action: ACTION.WITH_PLUGIN_STATE_CALLED,
-                actionSubject: ACTION_SUBJECT.EDITOR,
-                eventType: EVENT_TYPE.OPERATIONAL,
-                attributes: {
-                  plugin: pluginName,
-                  duration,
-                  participants: getParticipantsCount(editorView && editorView.state)
-                }
-              });
-            }
-          });
-        });
-        this.debounce = null;
-        this.notAppliedState = {};
-      });
-    });
-
-    _defineProperty(this, "dispatchAnalyticsEvent", payload => {
-      const eventDispatcher = this.getEventDispatcher();
-
-      if (eventDispatcher) {
-        const dispatch = createDispatch(eventDispatcher);
-        dispatch(analyticsEventKey, {
-          payload
-        });
-      }
-    });
-
-    _defineProperty(this, "onContextUpdate", () => {
-      this.subscribe(this.props);
-    });
-  }
-
-  getEditorView(maybeProps, maybeContext) {
-    const props = maybeProps || this.props;
-    const context = maybeContext || this.context;
-    return props.editorView || context && context.editorActions && context.editorActions._privateGetEditorView() || context && context.editorSharedConfig && context.editorSharedConfig.editorView;
-  }
-
-  getEventDispatcher(maybeProps) {
-    const props = maybeProps || this.props;
-    return props.eventDispatcher || this.context && this.context.editorActions && this.context.editorActions._privateGetEventDispatcher() || this.context && this.context.editorSharedConfig && this.context.editorSharedConfig.eventDispatcher;
-  }
-
-  getPluginsStates(plugins, editorView) {
-    if (!editorView || !plugins) {
-      return {};
-    }
-
-    const keys = Object.keys(plugins);
-    return keys.reduce((acc, propName) => {
-      const pluginKey = plugins[propName];
-
-      if (!pluginKey) {
-        return acc;
-      }
-
-      acc[propName] = pluginKey.getState(editorView.state);
-      return acc;
-    }, {});
-  }
-
-  subscribe(props) {
-    const plugins = props.plugins;
-    const eventDispatcher = this.getEventDispatcher(props);
-    const editorView = this.getEditorView(props);
-
-    if (!eventDispatcher || !editorView || this.isSubscribed) {
-      return;
-    }
-
-    const analyticsPlugin = analyticsPluginKey.getState(editorView.state);
-    const uiTracking = analyticsPlugin && analyticsPlugin.performanceTracking ? analyticsPlugin.performanceTracking.uiTracking || {} : {};
-    const trackingEnabled = uiTracking.enabled === true;
-    const samplingRate = uiTracking.samplingRate || DEFAULT_SAMPLING_RATE;
-    const slowThreshold = uiTracking.slowThreshold || DEFAULT_SLOW_THRESHOLD;
-    this.isSubscribed = true;
-    const pluginsStates = this.getPluginsStates(plugins, editorView);
-    this.setState(pluginsStates);
-    Object.keys(plugins).forEach(propName => {
-      const pluginKey = plugins[propName];
-
-      if (!pluginKey) {
-        return;
-      }
-
-      const pluginName = pluginKey.key;
-      const pluginState = pluginsStates[propName];
-      const isPluginWithSubscribe = pluginState && pluginState.subscribe;
-      const handler = this.handlePluginStateChange(propName, pluginName, {
-        samplingRate,
-        slowThreshold,
-        trackingEnabled
-      }, isPluginWithSubscribe);
-
-      if (isPluginWithSubscribe) {
-        pluginState.subscribe(handler);
-      } else {
-        eventDispatcher.on(pluginKey.key, handler);
-      }
-
-      this.listeners[pluginKey.key] = {
-        handler,
-        pluginKey
-      };
-    });
-  }
-
-  unsubscribe() {
-    const eventDispatcher = this.getEventDispatcher();
-    const editorView = this.getEditorView();
-
-    if (!eventDispatcher || !editorView || !this.isSubscribed) {
-      return;
-    }
-
-    Object.keys(this.listeners).forEach(key => {
-      const pluginState = this.listeners[key].pluginKey.getState(editorView.state);
-
-      if (pluginState && pluginState.unsubscribe) {
-        pluginState.unsubscribe(this.listeners[key].handler);
-      } else {
-        eventDispatcher.off(key, this.listeners[key].handler);
-      }
-    });
-    this.listeners = [];
-  }
-
-  subscribeToContextUpdates(context) {
-    if (context && context.editorActions) {
-      context.editorActions._privateSubscribe(this.onContextUpdate);
-    }
-  }
-
-  unsubscribeFromContextUpdates(context) {
-    if (context && context.editorActions) {
-      context.editorActions._privateUnsubscribe(this.onContextUpdate);
-    }
-  }
-
-  componentDidMount() {
-    this.subscribe(this.props);
-    this.subscribeToContextUpdates(this.context);
-  }
-
-  UNSAFE_componentWillReceiveProps(nextProps) {
-    if (!this.isSubscribed) {
-      this.subscribe(nextProps);
-    }
-  }
-
-  componentWillUnmount() {
-    if (this.debounce) {
-      window.clearTimeout(this.debounce);
-    }
-
-    this.unsubscribeFromContextUpdates(this.context);
-    this.unsubscribe();
-  }
-
-  render() {
-    const {
-      render
-    } = this.props;
-    return render(this.state);
-  }
-
-}
-
-_defineProperty(WithPluginState, "displayName", 'WithPluginState');
-
-_defineProperty(WithPluginState, "contextTypes", {
-  editorActions: PropTypes.object,
-  editorSharedConfig: PropTypes.object
-});
+import { WithPluginState } from '@atlaskit/editor-common/with-plugin-state';
+export default WithPluginState;

package/dist/es2019/utils/commands.js

@@ -2,6 +2,7 @@ import { TextSelection, NodeSelection } from 'prosemirror-state';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { transformSmartCharsMentionsAndEmojis } from '../plugins/text-formatting/commands/transform-to-code';
 import { GapCursorSelection } from '../plugins/selection/gap-cursor-selection';
+import { isEmptyParagraph } from './document';
 
 const filter = (predicates, cmd) => {
   return function (state, dispatch, view) {
@@ -279,5 +280,46 @@ const selectNode = pos => (state, dispatch) => {
 
   return true;
 };
+/**
+ * If the selection is empty, is inside a paragraph node and `canNextNodeMoveUp` is true then delete current paragraph
+ * and move the node below it up. The selection will be retained, to be placed in the moved node.
+ *
+ * @param canNextNodeMoveUp check if node directly after the selection is able to be brought up to selection
+ * @returns PM Command
+ */
+
+
+const deleteEmptyParagraphAndMoveBlockUp = canNextNodeMoveUp => {
+  return (state, dispatch, view) => {
+    const {
+      selection: {
+        $from: {
+          pos,
+          parent
+        },
+        $head,
+        empty
+      },
+      tr,
+      doc
+    } = state;
+    const {
+      $pos
+    } = walkNextNode($head);
+    const nextPMNode = doc.nodeAt($pos.pos - 1);
+
+    if (empty && nextPMNode && canNextNodeMoveUp(nextPMNode) && isEmptyParagraph(parent) && view !== null && view !== void 0 && view.endOfTextblock('right')) {
+      tr.deleteRange(pos - 1, pos + 1);
+
+      if (dispatch) {
+        dispatch(tr);
+      }
+
+      return true;
+    }
+
+    return false;
+  };
+};
 
-export { filter, isEmptySelectionAtStart, isEmptySelectionAtEnd, isFirstChildOfParent, isNthParentOfType, findCutBefore, toggleMark, applyMarkOnRange, withScrollIntoView, walkNextNode, walkPrevNode, insertContentDeleteRange, selectNode };
+export { filter, isEmptySelectionAtStart, isEmptySelectionAtEnd, isFirstChildOfParent, isNthParentOfType, findCutBefore, toggleMark, applyMarkOnRange, withScrollIntoView, walkNextNode, walkPrevNode, insertContentDeleteRange, selectNode, deleteEmptyParagraphAndMoveBlockUp };

package/dist/es2019/utils/input-rules.js

@@ -2,7 +2,7 @@ import { canJoin, findWrapping } from 'prosemirror-transform';
 import { closeHistory } from 'prosemirror-history';
 import { TextSelection } from 'prosemirror-state';
 import { addAnalytics } from '../plugins/analytics/utils';
-import { createInputRulePlugin, MAX_REGEX_MATCH } from '@atlaskit/prosemirror-input-rules';
+import { createInputRulePlugin } from '@atlaskit/prosemirror-input-rules';
 export const ruleWithAnalytics = getPayload => {
   return originalRule => {
     const onHandlerApply = (state, tr, matchResult) => {
@@ -46,14 +46,9 @@ export const createRule = (match, handler) => {
 export const createPlugin = (pluginName, rules, options = {}) => {
   const {
     isBlockNodeRule = false,
-    allowInsertTextOnDocument = true,
-    useUnpredictableInputRule = true
+    allowInsertTextOnDocument = true
   } = options;
 
-  if (useUnpredictableInputRule) {
-    return createUnpredictableInputRulePlugin(pluginName, rules, isBlockNodeRule);
-  }
-
   const onInputEvent = ({
     state,
     from,
@@ -173,130 +168,4 @@ const isCursorInsideUnsupportedMarks = (state, marksNameUnsupported) => {
   const isUnsupportedMark = node => marksNameUnsupported.includes(node.type.name);
 
   return Boolean($cursor === null || $cursor === void 0 ? void 0 : (_$cursor$nodeBefore = $cursor.nodeBefore) === null || _$cursor$nodeBefore === void 0 ? void 0 : (_$cursor$nodeBefore$m = _$cursor$nodeBefore.marks) === null || _$cursor$nodeBefore$m === void 0 ? void 0 : _$cursor$nodeBefore$m.some(isUnsupportedMark));
-}; // UnPredictable Input Rule
-// After the new UndoRedo system being rollout,
-// The function below can be removed.
-// https://product-fabric.atlassian.net/browse/ED-12676
-
-
-import { inputRules as unpredictableInputRulesPlugin, InputRule as UnpredictableInputRule } from 'prosemirror-inputrules';
-import { startMeasure, stopMeasure } from '@atlaskit/editor-common/utils';
-
-function createUnpredictableInputRulePlugin(pluginName, rules, isBlockNodeRule = false) {
-  const hasUnsupportedMarkForBlockInputRule = (state, start, end) => {
-    const {
-      doc,
-      schema: {
-        marks
-      }
-    } = state;
-    let unsupportedMarksPresent = false;
-
-    const isUnsupportedMark = node => node.type === marks.code || node.type === marks.link || node.type === marks.typeAheadQuery;
-
-    doc.nodesBetween(start, end, node => {
-      unsupportedMarksPresent = unsupportedMarksPresent || node.marks.filter(isUnsupportedMark).length > 0;
-    });
-    return unsupportedMarksPresent;
-  };
-
-  const hasUnsupportedMarkForInputRule = (state, start, end) => {
-    const {
-      doc,
-      schema: {
-        marks
-      }
-    } = state;
-    let unsupportedMarksPresent = false;
-
-    const isCodemark = mark => mark.type === marks.code;
-
-    doc.nodesBetween(start, end, node => {
-      unsupportedMarksPresent = unsupportedMarksPresent || node.marks.filter(isCodemark).length > 0;
-    });
-    return unsupportedMarksPresent;
-  };
-
-  const wrapUnsupportedMarkCheck = inputRule => {
-    const originalHandler = inputRule.handler.bind(inputRule);
-
-    inputRule.handler = (state, match, start, end) => {
-      const unsupportedMarks = isBlockNodeRule ? hasUnsupportedMarkForBlockInputRule(state, start, end) : hasUnsupportedMarkForInputRule(state, start, end);
-      const $from = state.selection.$from;
-
-      if ($from.parent.type.spec.code || !(state.selection instanceof TextSelection) || unsupportedMarks) {
-        return null;
-      }
-
-      return originalHandler(state, match, start, end);
-    };
-
-    return inputRule;
-  };
-
-  const wrapFixPositions = inputRule => {
-    const originalHandler = inputRule.handler.bind(inputRule);
-
-    inputRule.handler = (state, match, start, end) => {
-      const parentNodeStartAt = state.selection.$from.start();
-      const offset = Math.max(0, state.selection.$from.parentOffset - MAX_REGEX_MATCH);
-      const fromFixed = Math.max(parentNodeStartAt + match.index + offset, 1);
-      return originalHandler(state, match, fromFixed, end);
-    };
-
-    return inputRule;
-  };
-
-  const wrapWithOnHandlerApply = onHandlerApply => inputRule => {
-    if (!onHandlerApply) {
-      return inputRule;
-    }
-
-    const originalHandler = inputRule.handler.bind(inputRule);
-
-    inputRule.handler = (state, match, start, end) => {
-      const result = originalHandler(state, match, start, end);
-
-      if (result && onHandlerApply) {
-        onHandlerApply(state, result, match);
-      }
-
-      return result;
-    };
-
-    return inputRule;
-  };
-
-  const createUnpredictableRule = (match, handler, onHandlerApply) => {
-    const unpredictableRule = new UnpredictableInputRule(match, handler);
-    const rule = [wrapUnsupportedMarkCheck, wrapFixPositions, wrapWithOnHandlerApply(onHandlerApply)].reduce((acc, cb) => cb(acc), unpredictableRule);
-    return rule;
-  };
-
-  const unpredictableRules = rules.map(rule => {
-    const {
-      match,
-      handler,
-      onHandlerApply
-    } = rule;
-    const unpredictableRule = createUnpredictableRule(match, handler, onHandlerApply);
-    return unpredictableRule;
-  });
-  const plugin = unpredictableInputRulesPlugin({
-    rules: unpredictableRules
-  });
-
-  if (process.env.NODE_ENV !== 'production') {
-    const handleTextInput = plugin.props.handleTextInput;
-    const timerId = `input-rule:${pluginName}`;
-
-    plugin.props.handleTextInput = (view, from, to, text) => {
-      startMeasure(timerId);
-      const result = handleTextInput(view, from, to, text);
-      stopMeasure(timerId, () => {});
-      return result;
-    };
-  }
-
-  return plugin;
-}
+};

package/dist/es2019/utils/insert.js

@@ -87,10 +87,14 @@ export const safeInsert = (content, position) => tr => {
     }
   }
 
-  const grandParentType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
-  const parentType = tr.selection.$from.parent.type;
-
-  if (!lookDirection && !shouldSplitSelectedNodeOnNodeInsertion(parentType, grandParentType, content)) {
+  const grandParentNodeType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
+  const parentNodeType = tr.selection.$from.parent.type;
+
+  if (!lookDirection && !shouldSplitSelectedNodeOnNodeInsertion({
+    parentNodeType,
+    grandParentNodeType,
+    content
+  })) {
     // node to be inserted is an invalid child of selection so insert below selected node
     return pmSafeInsert(content, tr.selection.from)(tr);
   }
@@ -187,12 +191,19 @@ export const insertSelectedItem = (maybeNode, opts = {}) => (state, tr, start) =
   }
 
   return tr;
-}; // ED-14584: Util to check if the current node is a paragraph & the content being
-// inserted is a valid child of the grandparent node
-// In this case, the node being inserted to should split
+};
+/**
+ * ED-14584: Util to check if the destination node is a paragraph & the
+ * content being inserted is a valid child of the grandparent node.
+ * In this case, the destination node should split
+ */
 
-export const shouldSplitSelectedNodeOnNodeInsertion = (parentNodeType, grandParentNodeType, content) => {
-  if (parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
+export const shouldSplitSelectedNodeOnNodeInsertion = ({
+  parentNodeType,
+  grandParentNodeType,
+  content
+}) => {
+  if (parentNodeType.name === 'doc' || parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
     return true;
   }
 

package/dist/es2019/utils/nodes-by-localIds.js

@@ -1,12 +1,11 @@
 export const findNodePosByLocalIds = (state, ids, option = {}) => {
   var _state$doc$attrs;
 
-  const nodes = [];
-
   if (ids.length === 0) {
     return [];
   }
 
+  const nodes = [];
   const localIdSet = new Set(ids);
 
   if (option.includeDocNode && localIdSet.has((_state$doc$attrs = state.doc.attrs) === null || _state$doc$attrs === void 0 ? void 0 : _state$doc$attrs.localId)) {
@@ -27,6 +26,34 @@ export const findNodePosByLocalIds = (state, ids, option = {}) => {
     } // stop traversing once we found all the nodes
 
 
+    return localIdSet.size !== nodes.length;
+  });
+  return nodes;
+};
+export const findNodePosByFragmentLocalIds = (state, ids) => {
+  if (ids.length === 0) {
+    return [];
+  }
+
+  const nodes = [];
+  const localIdSet = new Set(ids);
+  state.doc.descendants((node, pos) => {
+    var _node$marks;
+
+    const fragmentLocalIdList = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.filter(m => m.type.name === 'fragment').map(m => {
+      var _m$attrs;
+
+      return (_m$attrs = m.attrs) === null || _m$attrs === void 0 ? void 0 : _m$attrs.localId;
+    }).filter(id => id && localIdSet.has(id));
+
+    if (fragmentLocalIdList.length > 0) {
+      nodes.push({
+        node,
+        pos
+      });
+    } // stop traversing once we found all the nodes
+
+
     return localIdSet.size !== nodes.length;
   });
   return nodes;

package/dist/es2019/utils/sendLogs.js

@@ -1,8 +1 @@
-export const sendLogs = body => fetch('https://analytics.atlassian.com/analytics/events', {
-  method: 'POST',
-  headers: {
-    Accept: 'application/json, */*',
-    'Content-Type': 'application/json'
-  },
-  body: JSON.stringify(body)
-});
+export { sendLogs } from '@atlaskit/editor-common/utils';

package/dist/es2019/version-wrapper.js

@@ -1,5 +1,5 @@
 export const name = "@atlaskit/editor-core";
-export const version = "173.0.1";
+export const version = "175.0.0";
 export const nextMajorVersion = () => {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-core",
-	"version": "173.0.1",
+	"version": "175.0.0",
 	"sideEffects": false
 }

package/dist/esm/actions/index.js

@@ -16,6 +16,7 @@ import { findNodePosWithLocalId } from '../plugins/extension/utils';
 import { getFeatureFlags } from '../plugins/feature-flags-context/get-feature-flags';
 import { getCollabProvider } from '../plugins/collab-edit/native-collab-provider-plugin';
 import deprecationWarnings from '../utils/deprecation-warnings';
+import { findNodePosByFragmentLocalIds } from '../utils/nodes-by-localIds';
 
 var EditorActions = /*#__PURE__*/function () {
   function EditorActions() {
@@ -286,6 +287,18 @@ var EditorActions = /*#__PURE__*/function () {
         return (_findNodePosWithLocal = findNodePosWithLocalId((_this$editorView2 = this.editorView) === null || _this$editorView2 === void 0 ? void 0 : _this$editorView2.state, id)) === null || _findNodePosWithLocal === void 0 ? void 0 : _findNodePosWithLocal.node;
       }
     }
+  }, {
+    key: "getNodeByFragmentLocalId",
+    value: function getNodeByFragmentLocalId(id) {
+      var _this$editorView3;
+
+      if ((_this$editorView3 = this.editorView) !== null && _this$editorView3 !== void 0 && _this$editorView3.state) {
+        var _this$editorView4;
+
+        var nodes = findNodePosByFragmentLocalIds((_this$editorView4 = this.editorView) === null || _this$editorView4 === void 0 ? void 0 : _this$editorView4.state, [id]);
+        return nodes.length > 0 ? nodes[0].node : undefined;
+      }
+    }
     /**
      * This method will return the currently selected `Node` if the selection is a `Node`.
      * Otherwise, if the selection is textual or a non-selectable `Node` within another selectable `Node`, the closest selectable parent `Node` will be returned.
@@ -294,9 +307,9 @@ var EditorActions = /*#__PURE__*/function () {
   }, {
     key: "getSelectedNode",
     value: function getSelectedNode() {
-      var _this$editorView3, _this$editorView3$sta;
+      var _this$editorView5, _this$editorView5$sta;
 
-      if ((_this$editorView3 = this.editorView) !== null && _this$editorView3 !== void 0 && (_this$editorView3$sta = _this$editorView3.state) !== null && _this$editorView3$sta !== void 0 && _this$editorView3$sta.selection) {
+      if ((_this$editorView5 = this.editorView) !== null && _this$editorView5 !== void 0 && (_this$editorView5$sta = _this$editorView5.state) !== null && _this$editorView5$sta !== void 0 && _this$editorView5$sta.selection) {
         var _findParentNode;
 
         var selection = this.editorView.state.selection;