@atlaskit/editor-common 69.2.1 → 69.3.0

package/dist/esm/utils/editor-core-utils.js

@@ -0,0 +1,72 @@
+import { NodeSelection, TextSelection } from 'prosemirror-state';
+import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+import { closest } from './dom';
+export var stepHasSlice = function stepHasSlice(step) {
+  return step && step.hasOwnProperty('slice');
+};
+/**
+ * Checks whether a given step is adding nodes of given nodeTypes
+ *
+ * @param step Step to check
+ * @param nodeTypes NodeTypes being added
+ */
+
+export function stepAddsOneOf(step, nodeTypes) {
+  var adds = false;
+
+  if (!stepHasSlice(step)) {
+    return adds;
+  }
+
+  step.slice.content.descendants(function (node) {
+    if (nodeTypes.has(node.type)) {
+      adds = true;
+    }
+
+    return !adds;
+  });
+  return adds;
+}
+export var extractSliceFromStep = function extractSliceFromStep(step) {
+  if (!(step instanceof ReplaceStep) && !(step instanceof ReplaceAroundStep)) {
+    return null;
+  } // @ts-ignore This is by design. Slice is a private property, but accesible, from ReplaceStep.
+  // However, we need to read it to found if the step was adding a newline
+
+
+  var slice = step.slice;
+  return slice;
+};
+export var isTextSelection = function isTextSelection(selection) {
+  return selection instanceof TextSelection;
+};
+export var isElementInTableCell = function isElementInTableCell(element) {
+  return closest(element, 'td') || closest(element, 'th');
+};
+export var isLastItemMediaGroup = function isLastItemMediaGroup(node) {
+  var content = node.content;
+  return !!content.lastChild && content.lastChild.type.name === 'mediaGroup';
+}; // TODO: pulled from `packages/editor/editor-core/src/utils/selection.ts`
+
+export var setNodeSelection = function setNodeSelection(view, pos) {
+  var state = view.state,
+      dispatch = view.dispatch;
+
+  if (!isFinite(pos)) {
+    return;
+  }
+
+  var tr = state.tr.setSelection(NodeSelection.create(state.doc, pos));
+  dispatch(tr);
+};
+export function nonNullable(value) {
+  return value !== null && value !== undefined;
+} // checks if the given position is within the ProseMirror document
+
+export var isValidPosition = function isValidPosition(pos, state) {
+  if (pos >= 0 && pos <= state.doc.resolve(0).end()) {
+    return true;
+  }
+
+  return false;
+};

package/dist/esm/utils/index.js

@@ -3,8 +3,13 @@ export { getExtensionLozengeData } from './macro';
 export { default as browser } from './browser';
 export { default as ErrorReporter } from './error-reporter';
 export { isPastDate, timestampToIsoFormat, timestampToString, timestampToTaskContext, timestampToUTCDate, todayTimestampInUTC } from './date';
+export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition } from './editor-core-utils';
 export { withImageLoader } from './imageLoader';
 export { absoluteBreakoutWidth, calcBreakoutWidth, calcWideWidth, breakoutConsts } from './breakout';
+export { findChangedNodesFromTransaction, validNode, validateNodes, isType, isParagraph, isText, isLinkMark, SelectedState, isNodeSelectedOrInRange, isSupportedInParent } from './nodes';
+export { pluginFactory } from './plugin-state-factory';
+export { getFragmentBackingArray, mapFragment, mapSlice, flatmap, mapChildren } from './slice';
+export { walkUpTreeUntil, unwrap, removeNestedEmptyEls, containsClassName, closest, closestElement, parsePx, mapElem, maphElem } from './dom';
 export { default as ADFTraversor } from './traversor';
 export { analyticsEventKey, getAnalyticsAppearance, getAnalyticsEventSeverity, SEVERITY, getUnsupportedContentLevelData, UNSUPPORTED_CONTENT_LEVEL_SEVERITY, UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS } from './analytics';
 export { findAndTrackUnsupportedContentNodes } from './track-unsupported-content';
@@ -17,6 +22,7 @@ export { getExtensionRenderer } from './extension-handler';
 export { hasMergedCell, calcTableColumnWidths, convertProsemirrorTableNodeToArrayOfRows } from './table';
 export { createCompareNodes } from './compareNodes';
 export { compose } from './compose';
+export { isTextInput } from './is-text-input';
 export { ZERO_WIDTH_SPACE } from './whitespace';
 export { shouldForceTracking } from './should-force-tracking';
 export { getModeFromTheme } from './getModeFromTheme';

package/dist/esm/utils/is-text-input.js

@@ -0,0 +1,18 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+// TODO: remove from editor-core utils, re-export from editor-common
+import { ReplaceStep } from 'prosemirror-transform';
+export var isTextInput = function isTextInput(tr) {
+  var _tr$steps = _slicedToArray(tr.steps, 1),
+      step = _tr$steps[0];
+
+  if (!step || !(step instanceof ReplaceStep)) {
+    return false;
+  }
+
+  var _ref = step,
+      content = _ref.slice.content,
+      from = _ref.from,
+      to = _ref.to;
+  var char = content.firstChild;
+  return from === to && content.childCount === 1 && !!char && !!char.text && char.text.length === 1;
+};

package/dist/esm/utils/nodes.js

@@ -0,0 +1,100 @@
+/**
+ * Finds all top level nodes affected by the transaction
+ * Uses from/to positions in transaction's steps to work out which nodes will
+ * be changed by the transaction
+ */
+export var findChangedNodesFromTransaction = function findChangedNodesFromTransaction(tr) {
+  var nodes = [];
+  var steps = tr.steps || [];
+  steps.forEach(function (step) {
+    var to = step.to,
+        from = step.from,
+        slice = step.slice;
+    var size = slice && slice.content ? slice.content.size : 0;
+
+    for (var i = from; i <= to + size; i++) {
+      if (i <= tr.doc.content.size) {
+        (function () {
+          var topLevelNode = tr.doc.resolve(i).node(1);
+
+          if (topLevelNode && !nodes.find(function (n) {
+            return n === topLevelNode;
+          })) {
+            nodes.push(topLevelNode);
+          }
+        })();
+      }
+    }
+  });
+  return nodes;
+};
+export var validNode = function validNode(node) {
+  try {
+    node.check(); // this will throw an error if the node is invalid
+  } catch (error) {
+    return false;
+  }
+
+  return true;
+};
+/** Validates prosemirror nodes, and returns true only if all nodes are valid */
+
+export var validateNodes = function validateNodes(nodes) {
+  return nodes.every(validNode);
+};
+export var isType = function isType(node, type) {
+  return type && node && node.type === type;
+};
+export var isParagraph = function isParagraph(node, schema) {
+  return isType(node, schema.nodes.paragraph);
+};
+export var isText = function isText(node, schema) {
+  return isType(node, schema.nodes.text);
+};
+export var isLinkMark = function isLinkMark(node, schema) {
+  return isType(node, schema.marks.link);
+};
+export var SelectedState;
+/**
+ * Returns if the current selection from achor-head is selecting the node.
+ * If the node is not selected then null is returned.
+ * If the node is selected then an enum is returned that describes weather the node
+ * is fully selected by a range or if the "inside" of the node has been selected or clicked.
+ */
+
+(function (SelectedState) {
+  SelectedState[SelectedState["selectedInRange"] = 0] = "selectedInRange";
+  SelectedState[SelectedState["selectedInside"] = 1] = "selectedInside";
+})(SelectedState || (SelectedState = {}));
+
+export var isNodeSelectedOrInRange = function isNodeSelectedOrInRange(anchorPosition, headPosition, nodePosition, nodeSize) {
+  var rangeStart = Math.min(anchorPosition, headPosition);
+  var rangeEnd = Math.max(anchorPosition, headPosition);
+  var nodeStart = nodePosition;
+  var nodeEnd = nodePosition + nodeSize;
+
+  if (anchorPosition === headPosition) {
+    return null;
+  }
+
+  if (rangeStart <= nodeStart && nodeEnd < rangeEnd || rangeStart < nodeStart && nodeEnd <= rangeEnd) {
+    return SelectedState.selectedInRange;
+  }
+
+  if (nodeStart <= anchorPosition && headPosition <= nodeEnd) {
+    return SelectedState.selectedInside;
+  }
+
+  return null;
+};
+/**
+ * Checks if a particular node fragment is supported in the parent
+ * @param state EditorState
+ * @param fragment The fragment to be checked for
+ */
+
+export var isSupportedInParent = function isSupportedInParent(state, fragment, currentAppearance) {
+  var depth = currentAppearance === 'embed' || currentAppearance === 'block' ? undefined : -1;
+  var parent = state.selection.$from.node(depth);
+  return parent && parent.type.validContent(fragment);
+};

package/dist/esm/utils/plugin-state-factory.js

@@ -0,0 +1,106 @@
+/**
+ * Creates a ProseMirror plugin's state and handles UI updates.
+ *
+ * Here's a few things to keep in mind:
+ * - plugin's state is stored as a single object
+ * - `Reducer` specifies how plugin's state changes in response to commands
+ * - `Command` describes only what happen, but not how state changes
+ * - `mapping` could be used to map ProseMirror positions stored in plugin's state
+ *
+ * Example:
+ *  const { createPluginState, createCommand, getPluginState } = pluginFactory(
+ *    reducer,
+ *    pluginKey
+ *  );
+ *
+ *  export const createPlugin = (dispatch: Dispatch, initialState) =>
+ *    new SafePlugin({
+ *      state: createPluginState(dispatch, initialState),
+ *      key: pluginKey
+ *    });
+ *
+ * Example of a reducer:
+ *
+ *  export const reducer = (
+ *    state: TablePluginState,
+ *    action: TableAction,
+ *  ): TablePluginState => {
+ *    switch (action.type) {
+ *      case 'TOGGLE_CONTEXTUAL_MENU':
+ *      return {
+ *        ...state,
+ *        isContextualMenuOpen: !state.isContextualMenuOpen,
+ *      };
+ *    default:
+ *      return state;
+ *    }
+ *  };
+ *
+ *
+ * Example of a command:
+ *
+ * export const toggleContextualMenu = createCommand({
+ *   type: 'TOGGLE_CONTEXTUAL_MENU',
+ * }, tr => tr.setMeta('addToHistory', false));
+ *
+ */
+function isFunction(x) {
+  return typeof x === 'function';
+}
+
+export function pluginFactory(pluginKey, reducer) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var mapping = options.mapping,
+      onDocChanged = options.onDocChanged,
+      onSelectionChanged = options.onSelectionChanged;
+  return {
+    createPluginState: function createPluginState(dispatch, initialState) {
+      return {
+        init: function init(_, state) {
+          return isFunction(initialState) ? initialState(state) : initialState;
+        },
+        apply: function apply(tr, _pluginState) {
+          var oldState = mapping ? mapping(tr, _pluginState) : _pluginState;
+          var newState = oldState;
+          var meta = tr.getMeta(pluginKey);
+
+          if (meta) {
+            newState = reducer(oldState, meta);
+          }
+
+          if (onDocChanged && tr.docChanged) {
+            newState = onDocChanged(tr, newState);
+          } else if (onSelectionChanged && tr.selectionSet) {
+            newState = onSelectionChanged(tr, newState);
+          }
+
+          if (newState !== oldState) {
+            dispatch(pluginKey, newState);
+          }
+
+          return newState;
+        }
+      };
+    },
+    createCommand: function createCommand(action, transform) {
+      return function (state, dispatch) {
+        if (dispatch) {
+          var _tr = transform ? transform(state.tr, state) : state.tr;
+
+          var resolvedAction = isFunction(action) ? action(state) : action;
+
+          if (_tr && resolvedAction) {
+            dispatch(_tr.setMeta(pluginKey, resolvedAction));
+          } else {
+            return false;
+          }
+        }
+
+        return true;
+      };
+    },
+    getPluginState: function getPluginState(state) {
+      return pluginKey.getState(state);
+    }
+  };
+}

package/dist/esm/utils/slice.js

@@ -0,0 +1,59 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { Fragment, Slice } from 'prosemirror-model';
+/**
+ * A helper to get the underlying array of a fragment.
+ */
+
+export function getFragmentBackingArray(fragment) {
+  return fragment.content;
+}
+export function mapFragment(content, callback) {
+  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  var children = [];
+
+  for (var i = 0, size = content.childCount; i < size; i++) {
+    var _node = content.child(i);
+
+    var transformed = _node.isLeaf ? callback(_node, parent, i) : callback(_node.copy(mapFragment(_node.content, callback, _node)), parent, i);
+
+    if (transformed) {
+      if (transformed instanceof Fragment) {
+        children.push.apply(children, _toConsumableArray(getFragmentBackingArray(transformed)));
+      } else if (Array.isArray(transformed)) {
+        children.push.apply(children, _toConsumableArray(transformed));
+      } else {
+        children.push(transformed);
+      }
+    }
+  }
+
+  return Fragment.fromArray(children);
+}
+export function mapSlice(slice, callback) {
+  var fragment = mapFragment(slice.content, callback);
+  return new Slice(fragment, slice.openStart, slice.openEnd);
+}
+export function flatmap(fragment, callback) {
+  var fragmentContent = [];
+
+  for (var i = 0; i < fragment.childCount; i++) {
+    var child = callback(fragment.child(i), i, fragment);
+
+    if (Array.isArray(child)) {
+      fragmentContent.push.apply(fragmentContent, _toConsumableArray(child));
+    } else {
+      fragmentContent.push(child);
+    }
+  }
+
+  return Fragment.fromArray(fragmentContent);
+}
+export function mapChildren(node, callback) {
+  var array = [];
+
+  for (var i = 0; i < node.childCount; i++) {
+    array.push(callback(node.child(i), i, node instanceof Fragment ? node : node.content));
+  }
+
+  return array;
+}

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "69.2.1",
+	"version": "69.3.0",
 	"sideEffects": false
 }