@atlaskit/editor-core 191.0.1 → 191.0.3

package/dist/es2019/plugins/extension/context-panel.js

@@ -1,181 +0,0 @@
-import React from 'react';
-import { getExtensionKeyAndNodeKey } from '@atlaskit/editor-common/extensions';
-import { getPluginState } from './pm-plugins/main';
-import { getSelectedExtension } from './utils';
-import ConfigPanelLoader from './ui/ConfigPanel/ConfigPanelLoader';
-import { clearEditingContext, forceAutoSave, updateState } from './commands';
-import { buildExtensionNode } from './actions';
-import { SaveIndicator } from './ui/SaveIndicator/SaveIndicator';
-import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
-import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { GapCursorSelection } from '@atlaskit/editor-common/selection';
-const areParametersEqual = (firstParameters, secondParameters) => {
-  if (typeof firstParameters === 'object' && typeof secondParameters === 'object' && firstParameters !== null && secondParameters !== null) {
-    const firstKeys = Object.keys(firstParameters);
-    const secondKeys = Object.keys(secondParameters);
-    return firstKeys.length === secondKeys.length && firstKeys.every(key => firstParameters[key] === secondParameters[key]);
-  }
-  return firstParameters === secondParameters;
-};
-export const duplicateSelection = (selectionToDuplicate, doc) => {
-  if (selectionToDuplicate instanceof NodeSelection) {
-    return NodeSelection.create(doc, selectionToDuplicate.from);
-  } else if (selectionToDuplicate instanceof TextSelection) {
-    return TextSelection.create(doc, selectionToDuplicate.from, selectionToDuplicate.to);
-  } else if (selectionToDuplicate instanceof GapCursorSelection) {
-    return new GapCursorSelection(doc.resolve(selectionToDuplicate.from), selectionToDuplicate.side);
-  } else if (selectionToDuplicate instanceof CellSelection) {
-    return new CellSelection(doc.resolve(selectionToDuplicate.$anchorCell.pos), doc.resolve(selectionToDuplicate.$headCell.pos));
-  }
-};
-export const getContextPanel = getEditorView => (allowAutoSave, featureFlags, applyChange) => state => {
-  const nodeWithPos = getSelectedExtension(state, true);
-
-  // Adding checks to bail out early
-  if (!nodeWithPos) {
-    return;
-  }
-  const extensionState = getPluginState(state);
-  const {
-    autoSaveResolve,
-    autoSaveReject,
-    showContextPanel,
-    extensionProvider,
-    processParametersBefore,
-    processParametersAfter
-  } = extensionState;
-  if (extensionState && showContextPanel && extensionProvider && processParametersAfter) {
-    const {
-      extensionType,
-      extensionKey,
-      parameters
-    } = nodeWithPos.node.attrs;
-    const [extKey, nodeKey] = getExtensionKeyAndNodeKey(extensionKey, extensionType);
-    const configParams = processParametersBefore ? processParametersBefore(parameters || {}) : parameters;
-    return /*#__PURE__*/React.createElement(SaveIndicator, {
-      duration: 5000,
-      visible: allowAutoSave
-    }, ({
-      onSaveStarted,
-      onSaveEnded
-    }) => {
-      const editorView = getEditorView === null || getEditorView === void 0 ? void 0 : getEditorView();
-      if (!editorView) {
-        return null;
-      }
-      return /*#__PURE__*/React.createElement(ConfigPanelLoader, {
-        showHeader: true,
-        closeOnEsc: true,
-        extensionType: extensionType,
-        extensionKey: extKey,
-        nodeKey: nodeKey,
-        extensionParameters: parameters,
-        parameters: configParams,
-        extensionProvider: extensionProvider,
-        autoSave: allowAutoSave,
-        autoSaveTrigger: autoSaveResolve,
-        autoSaveReject: autoSaveReject,
-        onChange: async updatedParameters => {
-          await onChangeAction(editorView, updatedParameters, parameters, nodeWithPos, onSaveStarted);
-          onSaveEnded();
-          if (autoSaveResolve) {
-            autoSaveResolve();
-          }
-          if (!allowAutoSave) {
-            clearEditingContext(applyChange)(editorView.state, editorView.dispatch);
-          }
-        },
-        onCancel: async () => {
-          if (allowAutoSave) {
-            try {
-              await new Promise((resolve, reject) => {
-                forceAutoSave(applyChange)(resolve, reject)(editorView.state, editorView.dispatch);
-              });
-            } catch (e) {
-              // Even if the save failed, we should proceed with closing the panel
-              // eslint-disable-next-line no-console
-              console.error(`Autosave failed with error`, e);
-            }
-          }
-          clearEditingContext(applyChange)(editorView.state, editorView.dispatch);
-        },
-        featureFlags: featureFlags
-      });
-    });
-  }
-};
-export async function onChangeAction(editorView, updatedParameters = {}, oldParameters = {}, nodeWithPos, onSaving) {
-  // WARNING: editorView.state stales quickly, do not unpack
-  const {
-    processParametersAfter,
-    processParametersBefore
-  } = getPluginState(editorView.state);
-  if (!processParametersAfter) {
-    return;
-  }
-  const unwrappedOldParameters = processParametersBefore ? processParametersBefore(oldParameters) : oldParameters;
-  // todo: update to only check parameters which are in the manifest's field definitions
-  if (areParametersEqual(unwrappedOldParameters, updatedParameters)) {
-    return;
-  }
-  if (onSaving) {
-    onSaving();
-  }
-  const key = Date.now();
-  const {
-    positions: previousPositions
-  } = getPluginState(editorView.state);
-  await updateState({
-    positions: {
-      ...previousPositions,
-      [key]: nodeWithPos.pos
-    }
-  })(editorView.state, editorView.dispatch);
-
-  // WARNING: after this, editorView.state may have changed
-  const newParameters = await processParametersAfter(updatedParameters);
-  const {
-    positions
-  } = getPluginState(editorView.state);
-  if (!positions) {
-    return;
-  }
-  if (!(key in positions)) {
-    return;
-  }
-  const {
-    node
-  } = nodeWithPos;
-  const newNode = buildExtensionNode(nodeWithPos.node.toJSON().type, editorView.state.schema, {
-    ...node.attrs,
-    parameters: {
-      ...oldParameters,
-      ...newParameters
-    }
-  }, node.content, node.marks);
-  if (!newNode) {
-    return;
-  }
-  const positionUpdated = positions[key];
-  const transaction = editorView.state.tr.replaceWith(positionUpdated, positionUpdated + newNode.nodeSize, newNode);
-
-  // Ensure we preserve the selection, tr.replaceWith causes it to be lost in some cases
-  // when replacing the node
-  const {
-    selection: prevSelection
-  } = editorView.state;
-  if (!prevSelection.eq(transaction.selection)) {
-    const selection = duplicateSelection(prevSelection, transaction.doc);
-    if (selection) {
-      transaction.setSelection(selection);
-    }
-  }
-  const positionsLess = {
-    ...getPluginState(editorView.state).positions
-  };
-  delete positionsLess[key];
-  await updateState({
-    positions: positionsLess
-  })(editorView.state, editorView.dispatch);
-  editorView.dispatch(transaction);
-}

package/dist/es2019/plugins/extension/extension-api.js

@@ -1,284 +0,0 @@
-import { validator } from '@atlaskit/adf-utils/validator';
-import { JSONTransformer } from '@atlaskit/editor-json-transformer';
-import { Fragment, Mark } from '@atlaskit/editor-prosemirror/model';
-import { NodeSelection, Selection } from '@atlaskit/editor-prosemirror/state';
-import { insertMacroFromMacroBrowser } from './pm-plugins/macro/actions';
-import { pluginKey as macroPluginKey } from './pm-plugins/macro/plugin-key';
-import { nodeToJSON } from '@atlaskit/editor-common/utils';
-import { setEditingContextToContextPanel } from './commands';
-import { findNodePosWithLocalId, getDataConsumerMark, getNodeTypesReferenced, getSelectedExtension } from './utils';
-import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { setTextSelection } from '@atlaskit/editor-prosemirror/utils';
-export const getEditInLegacyMacroBrowser = ({
-  view,
-  macroProvider,
-  editorAnalyticsAPI
-}) => {
-  return () => {
-    if (!view) {
-      throw new Error(`Missing view. Can't update without EditorView`);
-    }
-    if (!macroProvider) {
-      throw new Error(`Missing macroProvider. Can't use the macro browser for updates`);
-    }
-    const nodeWithPos = getSelectedExtension(view.state, true);
-    if (!nodeWithPos) {
-      throw new Error(`Missing nodeWithPos. Can't determine position of node`);
-    }
-    insertMacroFromMacroBrowser(editorAnalyticsAPI)(macroProvider, nodeWithPos.node, true)(view);
-  };
-};
-const extensionAPICallPayload = functionName => ({
-  action: ACTION.INVOKED,
-  actionSubject: ACTION_SUBJECT.EXTENSION,
-  actionSubjectId: ACTION_SUBJECT_ID.EXTENSION_API,
-  attributes: {
-    functionName
-  },
-  eventType: EVENT_TYPE.TRACK
-});
-export const createExtensionAPI = options => {
-  const {
-    editorView: {
-      state: {
-        schema
-      }
-    },
-    editorAnalyticsAPI
-  } = options;
-  const nodes = Object.keys(schema.nodes);
-  const marks = Object.keys(schema.marks);
-  const validate = validator(nodes, marks, {
-    allowPrivateAttributes: true
-  });
-
-  /**
-   * Finds the node and its position by `localId`. Throws if the node could not be found.
-   *
-   * @returns {NodeWithPos}
-   */
-  const ensureNodePosByLocalId = (localId, {
-    opName
-  }) => {
-    // Be extra cautious since 3rd party devs can use regular JS without type safety
-    if (typeof localId !== 'string' || localId === '') {
-      throw new Error(`${opName}(): Invalid localId '${localId}'.`);
-    }
-
-    // Find the node + position matching the given ID
-    const {
-      editorView: {
-        state
-      }
-    } = options;
-    const nodePos = findNodePosWithLocalId(state, localId);
-    if (!nodePos) {
-      throw new Error(`${opName}(): Could not find node with ID '${localId}'.`);
-    }
-    return nodePos;
-  };
-  const doc = {
-    insertAfter: (localId, adf, opt) => {
-      try {
-        validate(adf);
-      } catch (e) {
-        throw new Error(`insertAfter(): Invalid ADF given.`);
-      }
-      const nodePos = ensureNodePosByLocalId(localId, {
-        opName: 'insertAfter'
-      });
-      const {
-        editorView
-      } = options;
-      const {
-        dispatch,
-        state
-      } = editorView;
-
-      // Validate the given ADF
-      const {
-        tr,
-        schema
-      } = state;
-      const nodeType = schema.nodes[adf.type];
-      if (!nodeType) {
-        throw new Error(`insertAfter(): Invalid ADF type '${adf.type}'.`);
-      }
-      const fragment = Fragment.fromJSON(schema, adf.content);
-      const marks = (adf.marks || []).map(markEntity => Mark.fromJSON(schema, markEntity));
-      const newNode = nodeType === null || nodeType === void 0 ? void 0 : nodeType.createChecked(adf.attrs, fragment, marks);
-      if (!newNode) {
-        throw new Error('insertAfter(): Could not create a node for given ADFEntity.');
-      }
-      const insertPosition = nodePos.pos + nodePos.node.nodeSize;
-      tr.insert(insertPosition, newNode);
-
-      // Validate if the document is valid at this point
-      try {
-        tr.doc.check();
-      } catch (err) {
-        throw new Error(`insertAfter(): The given ADFEntity cannot be inserted in the current position.\n${err}`);
-      }
-
-      // Analytics - tracking the api call
-      const apiCallPayload = extensionAPICallPayload('insertAfter');
-      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(apiCallPayload)(tr);
-
-      // Analytics - tracking node types added
-      const nodesAdded = [newNode];
-      newNode.descendants(node => {
-        nodesAdded.push(node);
-        return true;
-      });
-      nodesAdded.forEach(node => {
-        const {
-          extensionKey,
-          extensionType
-        } = node.attrs;
-        const dataConsumerMark = getDataConsumerMark(node);
-        const stringIds = (dataConsumerMark === null || dataConsumerMark === void 0 ? void 0 : dataConsumerMark.attrs.sources.map(sourceId => sourceId)) || [];
-        const hasReferentiality = !!dataConsumerMark;
-        const nodeTypesReferenced = hasReferentiality ? getNodeTypesReferenced(stringIds, state) : undefined;
-
-        // fire off analytics for this ADF
-        const payload = {
-          action: ACTION.INSERTED,
-          actionSubject: ACTION_SUBJECT.DOCUMENT,
-          attributes: {
-            nodeType: node.type.name,
-            inputMethod: INPUT_METHOD.EXTENSION_API,
-            hasReferentiality,
-            nodeTypesReferenced,
-            layout: node.attrs.layout,
-            extensionType,
-            extensionKey
-          },
-          eventType: EVENT_TYPE.TRACK
-        };
-        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(payload)(tr);
-      });
-      if (opt && opt.allowSelectionToNewNode) {
-        tr.setSelection(new NodeSelection(tr.doc.resolve(insertPosition)));
-      }
-      dispatch(tr);
-    },
-    scrollTo: localId => {
-      const nodePos = ensureNodePosByLocalId(localId, {
-        opName: 'scrollTo'
-      });
-
-      // Analytics - tracking the api call
-      const apiCallPayload = extensionAPICallPayload('scrollTo');
-      const {
-        editorView: {
-          dispatch,
-          state
-        }
-      } = options;
-      let {
-        tr
-      } = state;
-      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(apiCallPayload)(tr);
-      tr = setTextSelection(nodePos.pos)(tr);
-      tr = tr.scrollIntoView();
-      dispatch(tr);
-    },
-    update: (localId, mutationCallback) => {
-      var _changedValues$marks;
-      const {
-        node,
-        pos
-      } = ensureNodePosByLocalId(localId, {
-        opName: 'update'
-      });
-      const {
-        editorView: {
-          dispatch,
-          state
-        }
-      } = options;
-      const {
-        tr,
-        schema
-      } = state;
-      const changedValues = mutationCallback({
-        content: nodeToJSON(node).content,
-        attrs: node.attrs,
-        marks: node.marks.map(pmMark => ({
-          type: pmMark.type.name,
-          attrs: pmMark.attrs
-        }))
-      });
-      const ensureValidMark = mark => {
-        if (typeof mark !== 'object' || Array.isArray(mark)) {
-          throw new Error(`update(): Invalid mark given.`);
-        }
-        const {
-          parent
-        } = state.doc.resolve(pos);
-        // Ensure that the given mark is present in the schema
-        const markType = schema.marks[mark.type];
-        if (!markType) {
-          throw new Error(`update(): Invalid ADF mark type '${mark.type}'.`);
-        }
-        if (!parent.type.allowsMarkType(markType)) {
-          throw new Error(`update(): Parent of type '${parent.type.name}' does not allow marks of type '${mark.type}'.`);
-        }
-        return {
-          mark: markType,
-          attrs: mark.attrs
-        };
-      };
-      const newMarks = changedValues.hasOwnProperty('marks') ? (_changedValues$marks = changedValues.marks) === null || _changedValues$marks === void 0 ? void 0 : _changedValues$marks.map(ensureValidMark).map(({
-        mark,
-        attrs
-      }) => mark.create(attrs)) : node.marks;
-      const newContent = changedValues.hasOwnProperty('content') ? Fragment.fromJSON(schema, changedValues.content) : node.content;
-      const newAttrs = changedValues.hasOwnProperty('attrs') ? changedValues.attrs : node.attrs;
-
-      // Validate if the new attributes, content and marks result in a valid node and adf.
-      try {
-        const newNode = node.type.createChecked(newAttrs, newContent, newMarks);
-        const newNodeAdf = new JSONTransformer().encodeNode(newNode);
-        validate(newNodeAdf);
-        tr.replaceWith(pos, pos + node.nodeSize, newNode);
-
-        // Keep selection if content does not change
-        if (newContent === node.content) {
-          tr.setSelection(Selection.fromJSON(tr.doc, state.selection.toJSON()));
-        }
-      } catch (err) {
-        throw new Error(`update(): The given ADFEntity cannot be inserted in the current position.\n${err}`);
-      }
-
-      // Analytics - tracking the api call
-      const apiCallPayload = extensionAPICallPayload('update');
-      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(apiCallPayload)(tr);
-      dispatch(tr);
-    }
-  };
-  return {
-    editInContextPanel: (transformBefore, transformAfter) => {
-      const {
-        editorView
-      } = options;
-      setEditingContextToContextPanel(transformBefore, transformAfter, options.applyChange)(editorView.state, editorView.dispatch, editorView);
-    },
-    _editInLegacyMacroBrowser: () => {
-      const {
-        editorView
-      } = options;
-      let editInLegacy = options.editInLegacyMacroBrowser;
-      if (!editInLegacy) {
-        const macroState = macroPluginKey.getState(editorView.state);
-        editInLegacy = getEditInLegacyMacroBrowser({
-          view: options.editorView,
-          macroProvider: (macroState === null || macroState === void 0 ? void 0 : macroState.macroProvider) || undefined,
-          editorAnalyticsAPI
-        });
-      }
-      editInLegacy();
-    },
-    doc
-  };
-};

package/dist/es2019/plugins/extension/index.js

@@ -1,128 +0,0 @@
-import { extension, bodiedExtension, inlineExtension, multiBodiedExtension, extensionFrame } from '@atlaskit/adf-schema';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { createPlugin } from './pm-plugins/main';
-import { createPlugin as createMacroPlugin } from './pm-plugins/macro';
-import { insertMacroFromMacroBrowser, runMacroAutoConvert } from './pm-plugins/macro/actions';
-import keymapPlugin from './pm-plugins/keymap';
-import { createPlugin as createUniqueIdPlugin } from './pm-plugins/unique-id';
-import { getToolbarConfig } from './toolbar';
-import { getContextPanel } from './context-panel';
-import { createExtensionAPI } from './extension-api';
-import { createEditSelectedExtensionAction } from './actions';
-import { getBooleanFF } from '@atlaskit/platform-feature-flags';
-const extensionPlugin = ({
-  config: options = {},
-  api
-}) => {
-  var _api$featureFlags, _api$analytics2, _api$analytics3, _api$contextPanel3, _api$analytics4, _api$contextPanel4;
-  const featureFlags = (api === null || api === void 0 ? void 0 : (_api$featureFlags = api.featureFlags) === null || _api$featureFlags === void 0 ? void 0 : _api$featureFlags.sharedState.currentState()) || {};
-  //Note: This is a hack to get the editor view reference in the plugin. Copied from table plugin.
-  //This is needed to get the current selection in the editor
-  const editorViewRef = {
-    current: null
-  };
-  return {
-    name: 'extension',
-    nodes() {
-      const extensionNodes = [{
-        name: 'extension',
-        node: extension
-      }, {
-        name: 'bodiedExtension',
-        node: bodiedExtension
-      }, {
-        name: 'inlineExtension',
-        node: inlineExtension
-      }];
-
-      // Revert to returning all nodes without local variable, once FF is removed
-      if (getBooleanFF('platform.editor.multi-bodied-extension_0rygg')) {
-        extensionNodes.push({
-          name: 'extensionFrame',
-          node: extensionFrame
-        });
-        extensionNodes.push({
-          name: 'multiBodiedExtension',
-          node: multiBodiedExtension
-        });
-      }
-      return extensionNodes;
-    },
-    pmPlugins() {
-      return [{
-        name: 'extension',
-        plugin: ({
-          dispatch,
-          providerFactory,
-          portalProviderAPI,
-          eventDispatcher
-        }) => {
-          const extensionHandlers = options.extensionHandlers || {};
-          return createPlugin(dispatch, providerFactory, extensionHandlers, portalProviderAPI, eventDispatcher, api, options.useLongPressSelection, {
-            appearance: options.appearance
-          });
-        }
-      }, {
-        name: 'extensionKeymap',
-        plugin: () => {
-          var _api$contextPanel;
-          return keymapPlugin(api === null || api === void 0 ? void 0 : (_api$contextPanel = api.contextPanel) === null || _api$contextPanel === void 0 ? void 0 : _api$contextPanel.actions.applyChange);
-        }
-      }, {
-        name: 'extensionUniqueId',
-        plugin: () => createUniqueIdPlugin()
-      }, {
-        name: 'extensionEditorViewRef',
-        plugin: () => {
-          return new SafePlugin({
-            view: editorView => {
-              // Do not cleanup the editorViewRef on destroy
-              // because some functions may point to a stale
-              // reference and this means we will return null.
-              // EditorView is assumed to be stable so we do not need to
-              // cleanup.
-              // See: #hot-106316
-              editorViewRef.current = editorView;
-              return {};
-            }
-          });
-        }
-      }, {
-        name: 'macro',
-        plugin: ({
-          dispatch,
-          providerFactory
-        }) => createMacroPlugin(dispatch, providerFactory)
-      }];
-    },
-    actions: {
-      api: () => {
-        var _api$contextPanel2, _api$analytics;
-        return createExtensionAPI({
-          editorView: editorViewRef.current,
-          applyChange: api === null || api === void 0 ? void 0 : (_api$contextPanel2 = api.contextPanel) === null || _api$contextPanel2 === void 0 ? void 0 : _api$contextPanel2.actions.applyChange,
-          editorAnalyticsAPI: api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions
-        });
-      },
-      insertMacroFromMacroBrowser: insertMacroFromMacroBrowser(api === null || api === void 0 ? void 0 : (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions),
-      editSelectedExtension: createEditSelectedExtensionAction({
-        editorViewRef,
-        editorAnalyticsAPI: api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions
-      }),
-      runMacroAutoConvert
-    },
-    pluginsOptions: {
-      floatingToolbar: getToolbarConfig({
-        breakoutEnabled: options.breakoutEnabled,
-        hoverDecoration: api === null || api === void 0 ? void 0 : api.decorations.actions.hoverDecoration,
-        applyChangeToContextPanel: api === null || api === void 0 ? void 0 : (_api$contextPanel3 = api.contextPanel) === null || _api$contextPanel3 === void 0 ? void 0 : _api$contextPanel3.actions.applyChange,
-        editorAnalyticsAPI: api === null || api === void 0 ? void 0 : (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 ? void 0 : _api$analytics4.actions
-      }),
-      contextPanel: getContextPanel(() => {
-        var _editorViewRef$curren;
-        return (_editorViewRef$curren = editorViewRef.current) !== null && _editorViewRef$curren !== void 0 ? _editorViewRef$curren : undefined;
-      })(options.allowAutoSave, featureFlags, api === null || api === void 0 ? void 0 : (_api$contextPanel4 = api.contextPanel) === null || _api$contextPanel4 === void 0 ? void 0 : _api$contextPanel4.actions.applyChange)
-    }
-  };
-};
-export default extensionPlugin;

package/dist/es2019/plugins/extension/plugin-factory.js

@@ -1,26 +0,0 @@
-import { pluginFactory } from '@atlaskit/editor-common/utils';
-import reducer from './reducer';
-import { pluginKey } from './plugin-key';
-const factory = pluginFactory(pluginKey, reducer, {
-  mapping(tr, state) {
-    const {
-      positions: previousPositions
-    } = state;
-    if (!previousPositions) {
-      return state;
-    }
-    const positions = {
-      ...previousPositions
-    };
-    for (const key in positions) {
-      positions[key] = tr.mapping.map(positions[key]);
-    }
-    return {
-      ...state,
-      positions
-    };
-  }
-});
-export const createPluginState = factory.createPluginState;
-export const createCommand = factory.createCommand;
-export const getPluginState = factory.getPluginState;

package/dist/es2019/plugins/extension/plugin-key.js

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

package/dist/es2019/plugins/extension/pm-plugins/keymap.js

@@ -1,15 +0,0 @@
-import { keymap } from '@atlaskit/editor-prosemirror/keymap';
-import { getPluginState } from './main';
-import { bindKeymapWithCommand, escape } from '@atlaskit/editor-common/keymaps';
-import { clearEditingContext } from '../commands';
-export default function keymapPlugin(applyChange) {
-  const list = {};
-  bindKeymapWithCommand(escape.common, (state, dispatch) => {
-    const extensionState = getPluginState(state);
-    if (!extensionState.showContextPanel) {
-      return false;
-    }
-    return clearEditingContext(applyChange)(state, dispatch);
-  }, list);
-  return keymap(list);
-}