@atlaskit/editor-plugin-extension 0.4.2 → 0.5.1

package/dist/es2019/ui/ConfigPanel/use-abortable-effect/index.js

@@ -0,0 +1,46 @@
+import { useCallback, useEffect, useMemo } from 'react';
+const safeError = message => {
+  if (process.env.NODE_ENV !== 'production') {
+    throw new Error(message);
+  }
+
+  // eslint-disable-next-line no-console
+  console.error(message);
+};
+const createAbortController = () => {
+  if (typeof AbortController === 'undefined') {
+    safeError('Missing AbortController');
+  }
+  return new AbortController();
+};
+/**
+ * Similar to useEffect but integrated with the AbortController to make it useful for async operations.
+ * On unmount, the abort function will be called and the signal will be passed down to the function so
+ * we get the chance to cancel any operation we want.
+ *
+ * Note: This hook follows the signature of useEffect so it can be linted if enabled through the
+ * `additionalHooks` config.
+ *
+ * @param callback
+ * @param deps
+ */
+export function useAbortableEffect(callback, deps) {
+  const abortController = useMemo(() => createAbortController(),
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  deps);
+  const abort = useCallback(() => abortController.abort(), [abortController]);
+  // AFP-2511 TODO: Fix automatic suppressions below
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const fn = useCallback(callback, deps);
+  useEffect(() => {
+    const teardown = fn(abortController.signal);
+    return () => {
+      if (typeof teardown === 'function') {
+        teardown();
+      }
+      abort();
+    };
+  }, [abortController, abort, fn,
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  ...deps]);
+}

package/dist/es2019/ui/ConfigPanel/use-state-from-promise/index.js

@@ -0,0 +1,30 @@
+import { useCallback, useState } from 'react';
+import { useAbortableEffect } from '../use-abortable-effect';
+/**
+ * Similar to useState but deals with async values.
+ * Simply pass a promise and it will set the state when it resolves. It won't try to set if
+ * the component unmounts
+ *
+ * Note: This hook follows the signature of useEffect so it can be linted if enabled through the
+ * `additionalHooks` config.
+ *
+ * @param callback
+ * @param deps
+ */
+export function useStateFromPromise(callback, deps, initialValue) {
+  // AFP-2511 TODO: Fix automatic suppressions below
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const fn = useCallback(callback, deps);
+  const [value, setValue] = useState(initialValue);
+  useAbortableEffect(signal => {
+    Promise.resolve(fn()).then(result => {
+      if (signal.aborted) {
+        return;
+      }
+      setValue(result);
+    });
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [...deps]);
+  return [value, setValue];
+}

package/dist/es2019/ui/ConfigPanel/utils.js

@@ -0,0 +1,86 @@
+import { isOptionsGrouped } from '@atlaskit/select';
+import { ALLOWED_LOGGED_MACRO_PARAMS, ALLOWED_PARAM_TYPES } from './constants';
+import { ValidationError } from './types';
+export const validate = (field, value) => {
+  return validateRequired(field, value);
+};
+const isEmptyString = value => typeof value === 'string' && value === '';
+const isEmptyArray = value => Array.isArray(value) && value.length === 0;
+const getUngroupedOptions = groupedOptions => {
+  return groupedOptions.flatMap(option => option.options);
+};
+export const validateRequired = ({
+  isRequired,
+  isMultiple
+}, value) => {
+  if (isRequired) {
+    const isUndefined = typeof value === 'undefined';
+    const isEmpty = isEmptyString(value) || isMultiple && isEmptyArray(value) || false;
+    return isUndefined || isEmpty ? ValidationError.Required : undefined;
+  }
+  return undefined;
+};
+export const getOptionFromValue = (options, value) => {
+  if (!Array.isArray(options) || options.length === 0) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    if (isOptionsGrouped(options)) {
+      return getUngroupedOptions(options).filter(option => value.includes(option.value));
+    }
+    return options.filter(option => value.includes(option.value));
+  }
+  if (isOptionsGrouped(options)) {
+    return getUngroupedOptions(options).find(option => value === option.value);
+  }
+  return options.find(option => value === option.value);
+};
+
+// Atlaskit uses final-form to power the form.
+// Final-form will create nesting in the tree if a dot (.) is used in the name of the field.
+// A parent is provided from a <Fieldset /> and is appended to the name here for simplicity
+export const getSafeParentedName = (name, parentName) => {
+  if (parentName && name.indexOf(`${parentName}.`) === -1) {
+    return `${parentName}.${name}`;
+  }
+  return name;
+};
+const duplicateFieldRegex = /:[0-9]+$/;
+export const isDuplicateField = key => duplicateFieldRegex.test(key);
+export const getNameFromDuplicateField = key => key.replace(duplicateFieldRegex, '');
+
+// An overly cautious parser for sanitizing configuration parameters of UGC
+export const parseParamType = (paramValue, paramField) => {
+  if (paramValue && paramField) {
+    if (paramField.type === 'string') {
+      if (paramField.name === 'types') {
+        // Parse types field as an array of valid content types
+        const contentTypes = ['page', 'blogpost', 'comment', 'attachment'];
+        return paramValue && paramValue.split(',').map(type => type.trim()).filter(type => contentTypes.includes(type));
+      }
+      if (paramField.name === 'width') {
+        return parseFloat(paramValue);
+      }
+      // Strings are very risky - return empty string in case anything slips through
+      return '';
+    }
+    if (ALLOWED_PARAM_TYPES.includes(paramField.type)) {
+      // The param types defined here are already parsed and safe to log
+      return paramValue;
+    }
+  }
+  // Safety net
+  return null;
+};
+export const getLoggedParameters = (macroKey, currentParams, macroFields) => {
+  // Get the parameters only defined in the allowlist of logged macro/parameter keys
+  return Object.keys(currentParams).filter(paramKey => {
+    var _ALLOWED_LOGGED_MACRO;
+    return (_ALLOWED_LOGGED_MACRO = ALLOWED_LOGGED_MACRO_PARAMS[macroKey]) === null || _ALLOWED_LOGGED_MACRO === void 0 ? void 0 : _ALLOWED_LOGGED_MACRO.includes(paramKey);
+  }).reduce((obj, param) => {
+    return {
+      ...obj,
+      [param]: parseParamType(currentParams[param], macroFields === null || macroFields === void 0 ? void 0 : macroFields.find(field => field.name === param))
+    };
+  }, {});
+};

package/dist/es2019/ui/SaveIndicator/SaveIndicator.js

@@ -0,0 +1,66 @@
+/** @jsx jsx */
+
+import { Fragment, useCallback, useEffect, useRef, useState } from 'react';
+import { css, jsx } from '@emotion/react';
+import { FormattedMessage } from 'react-intl-next';
+import CheckCircleIcon from '@atlaskit/icon/glyph/check-circle';
+import { G300, N0 } from '@atlaskit/theme/colors';
+import { messages } from './messages';
+const noop = () => {};
+const saveIndicatorWrapperStyles = css({
+  display: 'flex',
+  justifyContent: 'center'
+});
+const saveIndicatorContentStyles = css({
+  position: 'fixed',
+  width: '256px',
+  bottom: "var(--ds-space-250, 20px)",
+  display: 'flex',
+  flexDirection: 'row',
+  alignItems: 'center',
+  padding: `${"var(--ds-space-075, 6px)"} ${"var(--ds-space-150, 12px)"}`,
+  background: `var(--ds-surface-overlay, ${N0})`,
+  /* E300 */
+  boxShadow: `var(--ds-shadow-overlay, ${`0px 8px 12px rgba(9, 30, 66, 0.15), 0px 0px 1px rgba(9, 30, 66, 0.31)`})`,
+  borderRadius: '16px'
+});
+const saveIndicatorTextStyles = css({
+  paddingLeft: "var(--ds-space-075, 6px)"
+});
+export const SaveIndicator = ({
+  children,
+  duration,
+  visible = true
+}) => {
+  const [saving, setSaving] = useState(false);
+  const shown = useRef(false);
+  const onSaveStarted = useCallback(() => {
+    if (!shown.current) {
+      setSaving(true);
+      shown.current = true;
+    }
+  }, []);
+  useEffect(() => {
+    if (saving) {
+      const handleId = setTimeout(() => {
+        setSaving(false);
+      }, duration);
+      return () => clearTimeout(handleId);
+    }
+  }, [saving, duration]);
+  return jsx(Fragment, null, jsx("div", null, children({
+    onSaveStarted,
+    onSaveEnded: noop
+  })), visible && saving && jsx("div", {
+    css: saveIndicatorWrapperStyles
+  }, jsx("div", {
+    css: saveIndicatorContentStyles,
+    "data-testid": "save-indicator-content"
+  }, jsx(CheckCircleIcon, {
+    label: "Saving",
+    primaryColor: `var(--ds-icon-success, ${G300})`,
+    size: "small"
+  }), jsx("span", {
+    css: saveIndicatorTextStyles
+  }, jsx(FormattedMessage, messages.saveIndicator)))));
+};

package/dist/es2019/ui/SaveIndicator/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export const messages = defineMessages({
+  saveIndicator: {
+    id: 'fabric.editor.extensions.config-panel.save-indicator',
+    defaultMessage: 'All changes are always autosaved',
+    description: 'Message shown to the user to notify to them that we save the changes automatically.'
+  }
+});

package/dist/es2019/ui/SaveIndicator/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/utils.js

@@ -0,0 +1,65 @@
+import { closestElement, findNodePosByLocalIds } from '@atlaskit/editor-common/utils';
+import { findDomRefAtPos, findParentNodeOfType, findSelectedNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+export const getSelectedExtension = (state, searchParent = false) => {
+  const {
+    inlineExtension,
+    extension,
+    bodiedExtension,
+    multiBodiedExtension
+  } = state.schema.nodes;
+  const nodeTypes = [extension, bodiedExtension, inlineExtension, multiBodiedExtension];
+  return findSelectedNodeOfType(nodeTypes)(state.selection) || searchParent && findParentNodeOfType(nodeTypes)(state.selection) || undefined;
+};
+export const findExtensionWithLocalId = (state, localId) => {
+  const selectedExtension = getSelectedExtension(state, true);
+  if (!localId) {
+    return selectedExtension;
+  }
+  if (selectedExtension && selectedExtension.node.attrs.localId === localId) {
+    return selectedExtension;
+  }
+  const {
+    inlineExtension,
+    extension,
+    bodiedExtension,
+    multiBodiedExtension
+  } = state.schema.nodes;
+  const nodeTypes = [extension, bodiedExtension, inlineExtension, multiBodiedExtension];
+  let matched;
+  state.doc.descendants((node, pos) => {
+    if (nodeTypes.includes(node.type) && node.attrs.localId === localId) {
+      matched = {
+        node,
+        pos
+      };
+    }
+  });
+  return matched;
+};
+export const getSelectedDomElement = (schema, domAtPos, selectedExtensionNode) => {
+  const selectedExtensionDomNode = findDomRefAtPos(selectedExtensionNode.pos, domAtPos);
+  const isContentExtension = selectedExtensionNode.node.type !== schema.nodes.bodiedExtension;
+  return (
+    // Content extension can be nested in bodied-extension, the following check is necessary for that case
+    (isContentExtension ?
+    // Search down
+    selectedExtensionDomNode.querySelector('.extension-container') :
+    // Try searching up and then down
+    closestElement(selectedExtensionDomNode, '.extension-container') || selectedExtensionDomNode.querySelector('.extension-container')) || selectedExtensionDomNode
+  );
+};
+export const getDataConsumerMark = newNode => {
+  var _newNode$marks;
+  return (_newNode$marks = newNode.marks) === null || _newNode$marks === void 0 ? void 0 : _newNode$marks.find(mark => mark.type.name === 'dataConsumer');
+};
+export const getNodeTypesReferenced = (ids, state) => {
+  return findNodePosByLocalIds(state, ids, {
+    includeDocNode: true
+  }).map(({
+    node
+  }) => node.type.name);
+};
+export const findNodePosWithLocalId = (state, localId) => {
+  const nodes = findNodePosByLocalIds(state, [localId]);
+  return nodes.length >= 1 ? nodes[0] : undefined;
+};

package/dist/esm/actions.js

@@ -0,0 +1,223 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, INPUT_METHOD, TARGET_SELECTION_SOURCE } from '@atlaskit/editor-common/analytics';
+export { transformSliceToRemoveOpenBodiedExtension } from '@atlaskit/editor-common/transforms';
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findSelectedNodeOfType, replaceParentNodeOfType, replaceSelectedNode } from '@atlaskit/editor-prosemirror/utils';
+import { createExtensionAPI, getEditInLegacyMacroBrowser } from './extension-api';
+import { getPluginState } from './pm-plugins/main';
+import { findExtensionWithLocalId } from './utils';
+export var buildExtensionNode = function buildExtensionNode(type, schema, attrs, content, marks) {
+  switch (type) {
+    case 'extension':
+      return schema.nodes.extension.createChecked(attrs, content, marks);
+    case 'inlineExtension':
+      return schema.nodes.inlineExtension.createChecked(attrs, content, marks);
+    case 'bodiedExtension':
+      return schema.nodes.bodiedExtension.create(attrs, content, marks);
+  }
+};
+export var performNodeUpdate = function performNodeUpdate(editorAnalyticsAPI) {
+  return function (type, newAttrs, content, marks, shouldScrollIntoView) {
+    return function (_state, _dispatch, view) {
+      if (!view) {
+        throw Error('EditorView is required to perform node update!');
+      }
+      // NOTE: `state` and `dispatch` are stale at this point so we need to grab
+      // the latest one from `view` @see HOT-93986
+      var state = view.state,
+        dispatch = view.dispatch;
+      var newNode = buildExtensionNode(type, state.schema, newAttrs, content, marks);
+      if (!newNode) {
+        return false;
+      }
+      var selection = state.selection,
+        schema = state.schema;
+      var _schema$nodes = schema.nodes,
+        extension = _schema$nodes.extension,
+        inlineExtension = _schema$nodes.inlineExtension,
+        bodiedExtension = _schema$nodes.bodiedExtension;
+      var isBodiedExtensionSelected = !!findSelectedNodeOfType([bodiedExtension])(selection);
+      var extensionState = getPluginState(state);
+      var targetSelectionSource = TARGET_SELECTION_SOURCE.CURRENT_SELECTION;
+      var action = ACTION.UPDATED;
+      var tr = state.tr;
+
+      // When it's a bodiedExtension but not selected
+      if (newNode.type === bodiedExtension && !isBodiedExtensionSelected) {
+        // Bodied extensions can trigger an update when the cursor is inside which means that there is no node selected.
+        // To work around that we replace the parent and create a text selection instead of new node selection
+        tr = replaceParentNodeOfType(state.schema.nodes.bodiedExtension, newNode)(tr);
+        // Replacing selected node doesn't update the selection. `selection.node` still returns the old node
+        tr.setSelection(TextSelection.create(tr.doc, state.selection.anchor));
+      }
+      // If any extension is currently selected
+      else if (findSelectedNodeOfType([extension, bodiedExtension, inlineExtension])(selection)) {
+        tr = replaceSelectedNode(newNode)(tr);
+        // Replacing selected node doesn't update the selection. `selection.node` still returns the old node
+        tr.setSelection(NodeSelection.create(tr.doc, tr.mapping.map(state.selection.anchor)));
+      }
+      // When we loose the selection. This usually happens when Synchrony resets or changes
+      // the selection when user is in the middle of updating an extension.
+      else if (extensionState.element) {
+        var pos = view.posAtDOM(extensionState.element, -1);
+        if (pos > -1) {
+          tr = tr.replaceWith(pos, pos + (content.size || 0) + 1, newNode);
+          tr.setSelection(Selection.near(tr.doc.resolve(pos)));
+          targetSelectionSource = TARGET_SELECTION_SOURCE.HTML_ELEMENT;
+        } else {
+          action = ACTION.ERRORED;
+        }
+      }
+
+      // Only scroll if we have anything to update, best to avoid surprise scroll
+      if (dispatch && tr.docChanged) {
+        var _newNode$attrs = newNode.attrs,
+          extensionType = _newNode$attrs.extensionType,
+          extensionKey = _newNode$attrs.extensionKey,
+          layout = _newNode$attrs.layout,
+          localId = _newNode$attrs.localId;
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+          action: action,
+          actionSubject: ACTION_SUBJECT.EXTENSION,
+          actionSubjectId: newNode.type.name,
+          eventType: EVENT_TYPE.TRACK,
+          attributes: {
+            inputMethod: INPUT_METHOD.CONFIG_PANEL,
+            extensionType: extensionType,
+            extensionKey: extensionKey,
+            layout: layout,
+            localId: localId,
+            selection: tr.selection.toJSON(),
+            targetSelectionSource: targetSelectionSource
+          }
+        })(tr);
+        dispatch(shouldScrollIntoView ? tr.scrollIntoView() : tr);
+      }
+      return true;
+    };
+  };
+};
+var updateExtensionParams = function updateExtensionParams(editorAnalyticsAPI) {
+  return function (updateExtension, node, actions) {
+    return /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(state, dispatch, view) {
+        var _node$node, attrs, type, content, marks, parameters, newParameters, newAttrs;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _node$node = node.node, attrs = _node$node.attrs, type = _node$node.type, content = _node$node.content, marks = _node$node.marks;
+              if (state.schema.nodes[type.name]) {
+                _context.next = 3;
+                break;
+              }
+              return _context.abrupt("return", false);
+            case 3:
+              parameters = attrs.parameters;
+              _context.prev = 4;
+              _context.next = 7;
+              return updateExtension(parameters, actions);
+            case 7:
+              newParameters = _context.sent;
+              if (!newParameters) {
+                _context.next = 11;
+                break;
+              }
+              newAttrs = _objectSpread(_objectSpread({}, attrs), {}, {
+                parameters: _objectSpread(_objectSpread({}, parameters), newParameters)
+              });
+              return _context.abrupt("return", performNodeUpdate(editorAnalyticsAPI)(type.name, newAttrs, content, marks, true)(state, dispatch, view));
+            case 11:
+              _context.next = 15;
+              break;
+            case 13:
+              _context.prev = 13;
+              _context.t0 = _context["catch"](4);
+            case 15:
+              return _context.abrupt("return", true);
+            case 16:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[4, 13]]);
+      }));
+      return function (_x, _x2, _x3) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  };
+};
+
+// This is to decouple extensions from editor core
+// Ideally in the future we completely deprecate `EditorActions`
+export var editSelectedExtension = function editSelectedExtension(editorActions) {
+  var editorView = editorActions._privateGetEditorView();
+  var _getPluginState = getPluginState(editorView.state),
+    updateExtension = _getPluginState.updateExtension,
+    applyChangeToContextPanel = _getPluginState.applyChangeToContextPanel;
+  // The analytics API cannot be accessed in this case because
+  // we do not have access to the plugin injection API. Rather
+  // than change the way this works - we just won't use analytics
+  // here for now.
+  var editorAnalyticsAPI = undefined;
+  return editExtension(null, applyChangeToContextPanel, editorAnalyticsAPI, updateExtension)(editorView.state, editorView.dispatch, editorView);
+};
+export var editExtension = function editExtension(macroProvider, applyChangeToContextPanel, editorAnalyticsAPI, updateExtension) {
+  return function (state, dispatch, view) {
+    if (!view) {
+      return false;
+    }
+    var _getPluginState2 = getPluginState(state),
+      localId = _getPluginState2.localId;
+    var nodeWithPos = findExtensionWithLocalId(state, localId);
+    if (!nodeWithPos) {
+      return false;
+    }
+    var editInLegacyMacroBrowser = getEditInLegacyMacroBrowser({
+      view: view,
+      macroProvider: macroProvider || undefined,
+      editorAnalyticsAPI: editorAnalyticsAPI
+    });
+    if (updateExtension) {
+      updateExtension.then(function (updateMethod) {
+        if (updateMethod && view) {
+          var actions = createExtensionAPI({
+            editorView: view,
+            editInLegacyMacroBrowser: editInLegacyMacroBrowser,
+            applyChange: applyChangeToContextPanel,
+            editorAnalyticsAPI: editorAnalyticsAPI
+          });
+          updateExtensionParams(editorAnalyticsAPI)(updateMethod, nodeWithPos, actions)(state, dispatch, view);
+          return;
+        }
+        if (!updateMethod && macroProvider) {
+          editInLegacyMacroBrowser();
+          return;
+        }
+      });
+    } else {
+      if (!macroProvider) {
+        return false;
+      }
+      editInLegacyMacroBrowser();
+    }
+    return true;
+  };
+};
+export var createEditSelectedExtensionAction = function createEditSelectedExtensionAction(_ref2) {
+  var editorViewRef = _ref2.editorViewRef,
+    editorAnalyticsAPI = _ref2.editorAnalyticsAPI;
+  return function () {
+    var view = editorViewRef.current;
+    if (!view) {
+      return false;
+    }
+    var _getPluginState3 = getPluginState(view.state),
+      updateExtension = _getPluginState3.updateExtension,
+      applyChangeToContextPanel = _getPluginState3.applyChangeToContextPanel;
+    return editExtension(null, applyChangeToContextPanel, editorAnalyticsAPI, updateExtension)(view.state, view.dispatch, view);
+  };
+};

package/dist/esm/commands.js

@@ -0,0 +1,113 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { removeConnectedNodes } from '@atlaskit/editor-common/utils';
+import { findParentNodeOfType, removeParentNodeOfType, removeSelectedNode } from '@atlaskit/editor-prosemirror/utils';
+import { createCommand } from './plugin-factory';
+import { getSelectedExtension } from './utils';
+
+// AFP-2532 TODO: Fix automatic suppressions below
+// eslint-disable-next-line @atlassian/tangerine/import/entry-points
+
+export function updateState(state) {
+  return createCommand({
+    type: 'UPDATE_STATE',
+    data: state
+  });
+}
+export function setEditingContextToContextPanel(processParametersBefore, processParametersAfter, applyChangeToContextPanel) {
+  return createCommand({
+    type: 'UPDATE_STATE',
+    data: {
+      showContextPanel: true,
+      processParametersBefore: processParametersBefore,
+      processParametersAfter: processParametersAfter
+    }
+  }, applyChangeToContextPanel);
+}
+export var clearEditingContext = function clearEditingContext(applyChangeToContextPanel) {
+  return createCommand({
+    type: 'UPDATE_STATE',
+    data: {
+      showContextPanel: false,
+      processParametersBefore: undefined,
+      processParametersAfter: undefined
+    }
+  }, applyChangeToContextPanel);
+};
+export var forceAutoSave = function forceAutoSave(applyChangeToContextPanel) {
+  return function (resolve, reject) {
+    return createCommand({
+      type: 'UPDATE_STATE',
+      data: {
+        autoSaveResolve: resolve,
+        autoSaveReject: reject
+      }
+    }, applyChangeToContextPanel);
+  };
+};
+export var updateExtensionLayout = function updateExtensionLayout(layout) {
+  return createCommand({
+    type: 'UPDATE_STATE',
+    data: {
+      layout: layout
+    }
+  }, function (tr, state) {
+    var selectedExtension = getSelectedExtension(state, true);
+    if (selectedExtension) {
+      var trWithNewNodeMarkup = tr.setNodeMarkup(selectedExtension.pos, undefined, _objectSpread(_objectSpread({}, selectedExtension.node.attrs), {}, {
+        layout: layout
+      }));
+      trWithNewNodeMarkup.setMeta('scrollIntoView', false);
+      return trWithNewNodeMarkup;
+    }
+    return tr;
+  });
+};
+export var removeExtension = function removeExtension(editorAnalyticsAPI) {
+  return createCommand({
+    type: 'UPDATE_STATE',
+    data: {
+      element: undefined
+    }
+  }, function (tr, state) {
+    if (getSelectedExtension(state)) {
+      return removeSelectedNode(tr);
+    } else {
+      return checkAndRemoveExtensionNode(state, tr, editorAnalyticsAPI);
+    }
+  });
+};
+export var removeDescendantNodes = function removeDescendantNodes(sourceNode) {
+  return createCommand({
+    type: 'UPDATE_STATE',
+    data: {
+      element: undefined
+    }
+  }, function (tr, state) {
+    return sourceNode ? removeConnectedNodes(state, sourceNode) : tr;
+  });
+};
+export var checkAndRemoveExtensionNode = function checkAndRemoveExtensionNode(state, tr, analyticsApi) {
+  var nodeType = state.schema.nodes.bodiedExtension;
+  var maybeMBENode = findParentNodeOfType(state.schema.nodes.multiBodiedExtension)(state.selection);
+  if (maybeMBENode) {
+    nodeType = state.schema.nodes.multiBodiedExtension;
+    if (analyticsApi) {
+      analyticsApi.attachAnalyticsEvent({
+        action: ACTION.DELETED,
+        actionSubject: ACTION_SUBJECT.MULTI_BODIED_EXTENSION,
+        eventType: EVENT_TYPE.TRACK,
+        attributes: {
+          extensionType: maybeMBENode.node.attrs.extensionType,
+          extensionKey: maybeMBENode.node.attrs.extensionKey,
+          localId: maybeMBENode.node.attrs.localId,
+          maxFramesCount: maybeMBENode.node.attrs.maxFrames,
+          currentFramesCount: maybeMBENode.node.content.childCount
+        }
+      })(tr);
+    }
+  }
+  return removeParentNodeOfType(nodeType)(tr);
+};