@atlaskit/editor-core 190.1.20 → 190.1.24

package/dist/esm/plugins/annotation/ui/InlineCommentView.js

@@ -1,144 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import React from 'react';
-import { findDomRefAtPos } from '@atlaskit/editor-prosemirror/utils';
-import { getBooleanFF } from '@atlaskit/platform-feature-flags';
-import { AnnotationViewWrapper } from './AnnotationViewWrapper';
-import { AnnotationTestIds } from '../types';
-import { getAnnotationViewKey, getSelectionPositions, getPluginState, getAllAnnotations } from '../utils';
-import { removeInlineCommentNearSelection, updateInlineCommentResolvedState, setInlineCommentDraftState, createAnnotation, closeComponent } from '../commands';
-import { ACTION, ACTION_SUBJECT, EVENT_TYPE, ACTION_SUBJECT_ID } from '@atlaskit/editor-common/analytics';
-import { CONTENT_COMPONENT } from '@atlaskit/editor-common/analytics';
-import { RESOLVE_METHOD } from '@atlaskit/editor-common/analytics';
-var findPosForDOM = function findPosForDOM(sel) {
-  var $from = sel.$from,
-    from = sel.from;
-
-  // Retrieve current TextNode
-  var index = $from.index();
-  var node = index < $from.parent.childCount && $from.parent.child(index);
-
-  // Right edge of a mark.
-  if (!node && $from.nodeBefore && $from.nodeBefore.isText && $from.nodeBefore.marks.find(function (mark) {
-    return mark.type.name === 'annotation';
-  })) {
-    return from - 1;
-  }
-  return from;
-};
-export function InlineCommentView(_ref) {
-  var providers = _ref.providers,
-    editorView = _ref.editorView,
-    editorAnalyticsAPI = _ref.editorAnalyticsAPI,
-    dispatchAnalyticsEvent = _ref.dispatchAnalyticsEvent;
-  // As inlineComment is the only annotation present, this function is not generic
-  var inlineCommentProvider = providers.inlineComment;
-  var state = editorView.state,
-    dispatch = editorView.dispatch;
-  var CreateComponent = inlineCommentProvider.createComponent,
-    ViewComponent = inlineCommentProvider.viewComponent;
-  var inlineCommentState = getPluginState(state);
-  var _ref2 = inlineCommentState || {},
-    bookmark = _ref2.bookmark,
-    selectedAnnotations = _ref2.selectedAnnotations,
-    annotations = _ref2.annotations,
-    isInlineCommentViewClosed = _ref2.isInlineCommentViewClosed;
-  var annotationsList = getAllAnnotations(editorView.state.doc);
-  var selection = getSelectionPositions(state, inlineCommentState);
-  var position = findPosForDOM(selection);
-  var dom;
-  try {
-    dom = findDomRefAtPos(position, editorView.domAtPos.bind(editorView));
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.warn(error);
-    if (dispatchAnalyticsEvent) {
-      var payload = {
-        action: ACTION.ERRORED,
-        actionSubject: ACTION_SUBJECT.CONTENT_COMPONENT,
-        eventType: EVENT_TYPE.OPERATIONAL,
-        attributes: {
-          component: CONTENT_COMPONENT.INLINE_COMMENT,
-          selection: selection.toJSON(),
-          position: position,
-          docSize: editorView.state.doc.nodeSize,
-          error: error.toString()
-        }
-      };
-      dispatchAnalyticsEvent(payload);
-    }
-  }
-  if (!dom) {
-    return null;
-  }
-
-  // Create Component
-  if (bookmark) {
-    if (!CreateComponent) {
-      return null;
-    }
-
-    //getting all text between bookmarked positions
-    var textSelection = state.doc.textBetween(selection.from, selection.to);
-    return /*#__PURE__*/React.createElement("div", {
-      "data-testid": AnnotationTestIds.floatingComponent,
-      "data-editor-popup": "true"
-    }, /*#__PURE__*/React.createElement(CreateComponent, {
-      dom: dom,
-      textSelection: textSelection,
-      onCreate: function onCreate(id) {
-        createAnnotation(editorAnalyticsAPI)(id)(editorView.state, editorView.dispatch);
-        !editorView.hasFocus() && editorView.focus();
-      },
-      onClose: function onClose() {
-        setInlineCommentDraftState(editorAnalyticsAPI)(false)(editorView.state, editorView.dispatch);
-        !editorView.hasFocus() && editorView.focus();
-      }
-    }));
-  }
-
-  // View Component
-  var activeAnnotations = (selectedAnnotations === null || selectedAnnotations === void 0 ? void 0 : selectedAnnotations.filter(function (mark) {
-    return annotations && annotations[mark.id] === false;
-  })) || [];
-  if (!ViewComponent || activeAnnotations.length === 0) {
-    return null;
-  }
-  var onAnnotationViewed = function onAnnotationViewed() {
-    if (!dispatchAnalyticsEvent) {
-      return;
-    }
-    // fire analytics
-    var payload = {
-      action: ACTION.VIEWED,
-      actionSubject: ACTION_SUBJECT.ANNOTATION,
-      actionSubjectId: ACTION_SUBJECT_ID.INLINE_COMMENT,
-      eventType: EVENT_TYPE.TRACK,
-      attributes: {
-        overlap: activeAnnotations.length ? activeAnnotations.length - 1 : 0
-      }
-    };
-    dispatchAnalyticsEvent(payload);
-  };
-  if (getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox') && isInlineCommentViewClosed || !selectedAnnotations) {
-    return null;
-  }
-  return /*#__PURE__*/React.createElement(AnnotationViewWrapper, {
-    "data-editor-popup": "true",
-    "data-testid": AnnotationTestIds.floatingComponent,
-    key: getAnnotationViewKey(activeAnnotations),
-    onViewed: onAnnotationViewed
-  }, /*#__PURE__*/React.createElement(ViewComponent, {
-    annotationsList: annotationsList,
-    annotations: activeAnnotations,
-    dom: dom,
-    onDelete: function onDelete(id) {
-      return removeInlineCommentNearSelection(id)(state, dispatch);
-    },
-    onResolve: function onResolve(id) {
-      return updateInlineCommentResolvedState(editorAnalyticsAPI)(_defineProperty({}, id, true), RESOLVE_METHOD.COMPONENT)(editorView.state, editorView.dispatch);
-    },
-    onClose: function onClose() {
-      closeComponent()(editorView.state, editorView.dispatch);
-    }
-  }));
-}

package/dist/esm/plugins/annotation/update-provider.js

@@ -1,29 +0,0 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _get from "@babel/runtime/helpers/get";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-import { EventEmitter } from 'events';
-export var AnnotationUpdateEmitter = /*#__PURE__*/function (_EventEmitter) {
-  _inherits(AnnotationUpdateEmitter, _EventEmitter);
-  var _super = _createSuper(AnnotationUpdateEmitter);
-  function AnnotationUpdateEmitter() {
-    _classCallCheck(this, AnnotationUpdateEmitter);
-    return _super.apply(this, arguments);
-  }
-  _createClass(AnnotationUpdateEmitter, [{
-    key: "on",
-    value: function on(event, listener) {
-      return _get(_getPrototypeOf(AnnotationUpdateEmitter.prototype), "on", this).call(this, event, listener);
-    }
-  }, {
-    key: "off",
-    value: function off(event, listener) {
-      return _get(_getPrototypeOf(AnnotationUpdateEmitter.prototype), "removeListener", this).call(this, event, listener);
-    }
-  }]);
-  return AnnotationUpdateEmitter;
-}(EventEmitter);

package/dist/esm/plugins/annotation/utils.js

@@ -1,345 +0,0 @@
-import { PluginKey, TextSelection, AllSelection } from '@atlaskit/editor-prosemirror/state';
-import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import { AnnotationSharedClassNames } from '@atlaskit/editor-common/styles';
-import { canApplyAnnotationOnRange, getAnnotationIdsFromRange, isText, isParagraph, hasAnnotationMark, containsAnyAnnotations } from '@atlaskit/editor-common/utils';
-import { AnnotationTypes } from '@atlaskit/adf-schema';
-import { AnnotationSelectionType } from './types';
-import { ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, ACTION } from '@atlaskit/editor-common/analytics';
-export { hasAnnotationMark, containsAnyAnnotations };
-function sum(arr, f) {
-  return arr.reduce(function (val, x) {
-    return val + f(x);
-  }, 0);
-}
-/**
- * Finds the marks in the nodes to the left and right.
- * @param $pos Position to center search around
- */
-export var surroundingMarks = function surroundingMarks($pos) {
-  var nodeBefore = $pos.nodeBefore,
-    nodeAfter = $pos.nodeAfter;
-  var markNodeBefore = nodeBefore && $pos.doc.nodeAt(Math.max(0, $pos.pos - nodeBefore.nodeSize - 1));
-  var markNodeAfter = nodeAfter && $pos.doc.nodeAt($pos.pos + nodeAfter.nodeSize);
-  return [markNodeBefore && markNodeBefore.marks || [], markNodeAfter && markNodeAfter.marks || []];
-};
-
-/**
- * Finds annotation marks, and returns their IDs.
- * @param marks Array of marks to search in
- */
-var filterAnnotationIds = function filterAnnotationIds(marks) {
-  if (!marks.length) {
-    return [];
-  }
-  var annotation = marks[0].type.schema.marks.annotation;
-  return marks.filter(function (mark) {
-    return mark.type === annotation;
-  }).map(function (mark) {
-    return mark.attrs.id;
-  });
-};
-
-/**
- * Re-orders the annotation array based on the order in the document.
- *
- * This places the marks that do not appear in the surrounding nodes
- * higher in the list. That is, the inner-most one appears first.
- *
- * Undo, for example, can re-order annotation marks in the document.
- * @param annotations annotation metadata
- * @param $from location to look around (usually the selection)
- */
-var reorderAnnotations = function reorderAnnotations(annotations, $from) {
-  var idSet = surroundingMarks($from).map(filterAnnotationIds);
-  annotations.sort(function (a, b) {
-    return sum(idSet, function (ids) {
-      return ids.indexOf(a.id);
-    }) - sum(idSet, function (ids) {
-      return ids.indexOf(b.id);
-    });
-  });
-};
-export var getAllAnnotations = function getAllAnnotations(doc) {
-  var allAnnotationIds = new Set();
-  doc.descendants(function (node) {
-    node.marks.filter(function (mark) {
-      return mark.type.name === 'annotation';
-    })
-    // filter out annotations with invalid attributes as they cause errors when interacting with them
-    .filter(validateAnnotationMark).forEach(function (m) {
-      return allAnnotationIds.add(m.attrs.id);
-    });
-    return true;
-  });
-  return Array.from(allAnnotationIds);
-};
-
-/*
- * verifies if annotation mark contains valid attributes
- */
-var validateAnnotationMark = function validateAnnotationMark(annotationMark) {
-  var _ref = annotationMark.attrs,
-    id = _ref.id,
-    annotationType = _ref.annotationType;
-  return validateAnnotationId(id) && validateAnnotationType(annotationType);
-  function validateAnnotationId(id) {
-    if (!id || typeof id !== 'string') {
-      return false;
-    }
-    var invalidIds = ['null', 'undefined'];
-    return !invalidIds.includes(id.toLowerCase());
-  }
-  function validateAnnotationType(type) {
-    if (!type || typeof type !== 'string') {
-      return false;
-    }
-    var allowedTypes = Object.values(AnnotationTypes);
-    return allowedTypes.includes(type);
-  }
-};
-
-/*
- * add decoration for the comment selection in draft state
- * (when creating new comment)
- */
-export var addDraftDecoration = function addDraftDecoration(start, end) {
-  return Decoration.inline(start, end, {
-    class: "".concat(AnnotationSharedClassNames.draft)
-  });
-};
-export var getAnnotationViewKey = function getAnnotationViewKey(annotations) {
-  var keys = annotations.map(function (mark) {
-    return mark.id;
-  }).join('_');
-  return "view-annotation-wrapper_".concat(keys);
-};
-export var findAnnotationsInSelection = function findAnnotationsInSelection(selection, doc) {
-  var empty = selection.empty,
-    $anchor = selection.$anchor,
-    anchor = selection.anchor;
-  // Only detect annotations on caret selection
-  if (!empty || !doc) {
-    return [];
-  }
-  var node = doc.nodeAt(anchor);
-  if (!node && !$anchor.nodeBefore) {
-    return [];
-  }
-  var annotationMark = doc.type.schema.marks.annotation;
-  var nodeBefore = $anchor.nodeBefore;
-  var anchorAnnotationMarks = node && node.marks || [];
-  var marks = [];
-  if (annotationMark.isInSet(anchorAnnotationMarks)) {
-    marks = anchorAnnotationMarks;
-  } else if (nodeBefore && annotationMark.isInSet(nodeBefore.marks)) {
-    marks = nodeBefore.marks;
-  }
-  var annotations = marks.filter(function (mark) {
-    return mark.type.name === 'annotation';
-  }).map(function (mark) {
-    return {
-      id: mark.attrs.id,
-      type: mark.attrs.annotationType
-    };
-  });
-  reorderAnnotations(annotations, $anchor);
-  return annotations;
-};
-
-/**
- * get selection from position to apply new comment for
- * @return bookmarked positions if they exists, otherwise current selection positions
- */
-export function getSelectionPositions(editorState, inlineCommentState) {
-  var _ref2 = inlineCommentState || {},
-    bookmark = _ref2.bookmark;
-  // get positions via saved bookmark if it is available
-  // this is to make comments box positioned relative to temporary highlight rather then current selection
-  if (bookmark) {
-    return bookmark.resolve(editorState.doc);
-  }
-  return editorState.selection;
-}
-export var inlineCommentPluginKey = new PluginKey('inlineCommentPluginKey');
-export var getPluginState = function getPluginState(state) {
-  return inlineCommentPluginKey.getState(state);
-};
-
-/**
- * get number of unique annotations within current selection
- */
-var getAnnotationsInSelectionCount = function getAnnotationsInSelectionCount(state) {
-  var _state$selection = state.selection,
-    from = _state$selection.from,
-    to = _state$selection.to;
-  var annotations = getAnnotationIdsFromRange({
-    from: from,
-    to: to
-  }, state.doc, state.schema);
-  return annotations.length;
-};
-
-/**
- * get payload for the open/close analytics event
- */
-export var getDraftCommandAnalyticsPayload = function getDraftCommandAnalyticsPayload(drafting, inputMethod) {
-  var payload = function payload(state) {
-    var attributes = {};
-    if (drafting) {
-      attributes = {
-        inputMethod: inputMethod,
-        overlap: getAnnotationsInSelectionCount(state)
-      };
-    }
-    return {
-      action: drafting ? ACTION.OPENED : ACTION.CLOSED,
-      actionSubject: ACTION_SUBJECT.ANNOTATION,
-      actionSubjectId: ACTION_SUBJECT_ID.INLINE_COMMENT,
-      eventType: EVENT_TYPE.TRACK,
-      attributes: attributes
-    };
-  };
-  return payload;
-};
-export var isSelectionValid = function isSelectionValid(state) {
-  var selection = state.selection;
-  var _ref3 = getPluginState(state) || {},
-    disallowOnWhitespace = _ref3.disallowOnWhitespace;
-  if (selection.empty || !(selection instanceof TextSelection || selection instanceof AllSelection)) {
-    return AnnotationSelectionType.INVALID;
-  }
-  var containsInvalidNodes = hasInvalidNodes(state);
-
-  // A selection that only covers 1 pos, and is an invalid node
-  // e.g. a text selection over a mention
-  if (containsInvalidNodes && selection.to - selection.from === 1) {
-    return AnnotationSelectionType.INVALID;
-  }
-  if (containsInvalidNodes) {
-    return AnnotationSelectionType.DISABLED;
-  }
-  if (disallowOnWhitespace && hasInvalidWhitespaceNode(selection, state.schema)) {
-    return AnnotationSelectionType.INVALID;
-  }
-  if (isEmptyTextSelection(selection, state.schema)) {
-    return AnnotationSelectionType.INVALID;
-  }
-  return AnnotationSelectionType.VALID;
-};
-export var hasInvalidNodes = function hasInvalidNodes(state) {
-  var selection = state.selection,
-    doc = state.doc,
-    schema = state.schema;
-  return !canApplyAnnotationOnRange({
-    from: selection.from,
-    to: selection.to
-  }, doc, schema);
-};
-
-/**
- * Checks if selection contains only empty text
- * e.g. when you select across multiple empty paragraphs
- */
-function isEmptyTextSelection(selection, schema) {
-  var _schema$nodes = schema.nodes,
-    text = _schema$nodes.text,
-    paragraph = _schema$nodes.paragraph;
-  var hasContent = false;
-  selection.content().content.descendants(function (node) {
-    // for empty paragraph - consider empty (nothing to comment on)
-    if (node.type === paragraph && !node.content.size) {
-      return false;
-    }
-    // for not a text or nonempty text - consider nonempty (can comment if the node is supported for annotations)
-    if (node.type !== text || !node.textContent) {
-      hasContent = true;
-    }
-    return !hasContent;
-  });
-  return !hasContent;
-}
-
-/**
- * Checks if any of the nodes in a given selection are completely whitespace
- * This is to conform to Confluence annotation specifications
- */
-export function hasInvalidWhitespaceNode(selection, schema) {
-  var foundInvalidWhitespace = false;
-  var content = selection.content().content;
-  content.descendants(function (node) {
-    if (isText(node, schema)) {
-      return false;
-    }
-    if (node.textContent.trim() === '') {
-      // Trailing new lines do not result in the annotation spanning into
-      // the trailing new line so can be ignored when looking for invalid
-      // whitespace nodes.
-      var nodeIsTrailingNewLine =
-      // it is the final node
-      node.eq(content.lastChild) &&
-      // and there are multiple nodes
-      !node.eq(content.firstChild) &&
-      // and it is a paragraph node
-      isParagraph(node, schema);
-      if (!nodeIsTrailingNewLine) {
-        foundInvalidWhitespace = true;
-      }
-    }
-    return !foundInvalidWhitespace;
-  });
-  return foundInvalidWhitespace;
-}
-
-/*
- * verifies that the annotation exists by the given id
- */
-export function annotationExists(annotationId, state) {
-  var commentsPluginState = getPluginState(state);
-  return !!(commentsPluginState !== null && commentsPluginState !== void 0 && commentsPluginState.annotations) && Object.keys(commentsPluginState.annotations).includes(annotationId);
-}
-
-/*
- * remove annotations that dont exsist in plugin state from slice
- */
-export function stripNonExistingAnnotations(slice, state) {
-  if (!slice.content.size) {
-    return false;
-  }
-  slice.content.forEach(function (node) {
-    stripNonExistingAnnotationsFromNode(node, state);
-    node.content.descendants(function (node) {
-      stripNonExistingAnnotationsFromNode(node, state);
-      return true;
-    });
-  });
-}
-
-/*
- * remove annotations that dont exsist in plugin state
- * from node
- */
-function stripNonExistingAnnotationsFromNode(node, state) {
-  if (hasAnnotationMark(node, state)) {
-    node.marks = node.marks.filter(function (mark) {
-      if (mark.type.name === 'annotation') {
-        return annotationExists(mark.attrs.id, state);
-      }
-      return true;
-    });
-  }
-  return node;
-}
-
-/**
- * Compares two sets of annotationInfos to see if the annotations have changed
- * This function assumes annotations will have unique id's for simplicity
- */
-export function isSelectedAnnotationsChanged(oldSelectedAnnotations, newSelectedAnnotations) {
-  return newSelectedAnnotations.length !== oldSelectedAnnotations.length ||
-  // assuming annotations have unique id's for simplicity
-  newSelectedAnnotations.some(function (annotation) {
-    return !oldSelectedAnnotations.find(function (pluginStateAnnotation) {
-      return annotation.id === pluginStateAnnotation.id && annotation.type === pluginStateAnnotation.type;
-    });
-  });
-}

package/dist/types/plugins/annotation/commands/index.d.ts

@@ -1,15 +0,0 @@
-import type { EditorAnalyticsAPI, RESOLVE_METHOD } from '@atlaskit/editor-common/analytics';
-import type { Command } from '../../../types';
-import { AnnotationTypes } from '@atlaskit/adf-schema';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import type { InlineCommentMap, InlineCommentMouseData } from '../pm-plugins/types';
-export declare const updateInlineCommentResolvedState: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (partialNewState: InlineCommentMap, resolveMethod?: RESOLVE_METHOD) => Command;
-export declare const closeComponent: () => Command;
-export declare const clearDirtyMark: () => Command;
-export declare const removeInlineCommentNearSelection: (id: string) => Command;
-export declare const setInlineCommentDraftState: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (drafting: boolean, inputMethod?: INPUT_METHOD.TOOLBAR | INPUT_METHOD.SHORTCUT) => Command;
-export declare const addInlineComment: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (id: string) => Command;
-export declare const updateMouseState: (mouseData: InlineCommentMouseData) => Command;
-export declare const setSelectedAnnotation: (id: string) => Command;
-export declare const createAnnotation: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (id: string, annotationType?: AnnotationTypes) => Command;
-export declare const setInlineCommentsVisibility: (isVisible: boolean) => Command;

package/dist/types/plugins/annotation/commands/transform.d.ts

@@ -1,11 +0,0 @@
-import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import type { RESOLVE_METHOD, EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
-declare const _default: {
-    addAnnotationMark: (id: string) => (transaction: Transaction, state: EditorState) => Transaction;
-    addInlineComment: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (id: string) => (transaction: Transaction, state: EditorState) => Transaction;
-    addOpenCloseAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (drafting: boolean, method?: INPUT_METHOD.SHORTCUT | INPUT_METHOD.TOOLBAR) => (transaction: Transaction, state: EditorState) => Transaction;
-    addInsertAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (transaction: Transaction, state: EditorState) => Transaction;
-    addResolveAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (method?: RESOLVE_METHOD | undefined) => (transaction: Transaction, state: EditorState) => Transaction;
-};
-export default _default;

package/dist/types/plugins/annotation/index.d.ts

@@ -1,15 +0,0 @@
-import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
-import type { AnnotationProviders, InlineCommentAnnotationProvider, AnnotationInfo, AnnotationState, InlineCommentState, InlineCommentCreateComponentProps, InlineCommentViewComponentProps, AnnotationTypeProvider } from './types';
-import type { UpdateEvent } from './update-provider';
-import { AnnotationUpdateEmitter } from './update-provider';
-import type { InlineCommentPluginState } from './pm-plugins/types';
-import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
-export type AnnotationPlugin = NextEditorPlugin<'annotation', {
-    pluginConfiguration: AnnotationProviders | undefined;
-    sharedState: InlineCommentPluginState | undefined;
-    dependencies: [OptionalPlugin<AnalyticsPlugin>];
-}>;
-declare const annotationPlugin: AnnotationPlugin;
-export default annotationPlugin;
-export { AnnotationUpdateEmitter };
-export type { AnnotationProviders, InlineCommentAnnotationProvider, InlineCommentCreateComponentProps, InlineCommentViewComponentProps, AnnotationTypeProvider, AnnotationInfo, AnnotationState, InlineCommentState, UpdateEvent, };

package/dist/types/plugins/annotation/nodeviews/index.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="react" />
-import { ForwardRef } from '../../../nodeviews';
-import ReactNodeView from '@atlaskit/editor-common/react-node-view';
-export declare class AnnotationNodeView extends ReactNodeView {
-    createDomRef(): HTMLSpanElement;
-    getContentDOM(): {
-        dom: HTMLSpanElement;
-    };
-    render(_props: {}, forwardRef: ForwardRef): JSX.Element;
-}
-export declare const getAnnotationViewClassname: (isUnresolved: boolean, hasFocus: boolean) => string | undefined;

package/dist/types/plugins/annotation/pm-plugins/inline-comment.d.ts

@@ -1,3 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import type { InlineCommentPluginState, InlineCommentPluginOptions } from './types';
-export declare const inlineCommentPlugin: (options: InlineCommentPluginOptions) => SafePlugin<InlineCommentPluginState>;

package/dist/types/plugins/annotation/pm-plugins/keymap.d.ts

@@ -1,3 +0,0 @@
-import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
-export declare function keymapPlugin(editorAnalyticsAPI: EditorAnalyticsAPI | undefined): SafePlugin;

package/dist/types/plugins/annotation/pm-plugins/plugin-factory.d.ts

@@ -1,2 +0,0 @@
-import type { InlineCommentPluginState } from './types';
-export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: InlineCommentPluginState | ((state: import("prosemirror-state").EditorState) => InlineCommentPluginState)) => import("prosemirror-state").SafeStateField<InlineCommentPluginState>, createCommand: <A = import("./types").InlineCommentAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command;

package/dist/types/plugins/annotation/pm-plugins/reducer.d.ts

@@ -1,3 +0,0 @@
-import type { InlineCommentAction, InlineCommentPluginState } from './types';
-declare const _default: (pluginState: InlineCommentPluginState, action: InlineCommentAction) => InlineCommentPluginState;
-export default _default;

package/dist/types/plugins/annotation/pm-plugins/types.d.ts

@@ -1,78 +0,0 @@
-import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import type { EditorState, SelectionBookmark } from '@atlaskit/editor-prosemirror/state';
-import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
-import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
-import type { Dispatch, EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
-import type { InlineCommentAnnotationProvider, AnnotationInfo } from '../types';
-export declare enum ACTIONS {
-    UPDATE_INLINE_COMMENT_STATE = 0,
-    SET_INLINE_COMMENT_DRAFT_STATE = 1,
-    INLINE_COMMENT_UPDATE_MOUSE_STATE = 2,
-    INLINE_COMMENT_CLEAR_DIRTY_MARK = 3,
-    ADD_INLINE_COMMENT = 4,
-    INLINE_COMMENT_SET_VISIBLE = 5,
-    CLOSE_COMPONENT = 6,
-    SET_SELECTED_ANNOTATION = 7
-}
-export interface InlineCommentPluginOptions {
-    dispatch: Dispatch;
-    eventDispatcher: EventDispatcher;
-    portalProviderAPI: PortalProviderAPI;
-    provider: InlineCommentAnnotationProvider;
-    editorAnalyticsAPI: EditorAnalyticsAPI | undefined;
-}
-export interface InlineCommentMouseData {
-    isSelecting: boolean;
-}
-export type InlineCommentMap = {
-    [key: string]: boolean;
-};
-export type InlineCommentAction = {
-    type: ACTIONS.UPDATE_INLINE_COMMENT_STATE;
-    data: InlineCommentMap;
-} | {
-    type: ACTIONS.SET_INLINE_COMMENT_DRAFT_STATE;
-    data: {
-        drafting: boolean;
-        editorState: EditorState;
-    };
-} | {
-    type: ACTIONS.INLINE_COMMENT_UPDATE_MOUSE_STATE;
-    data: {
-        mouseData: InlineCommentMouseData;
-    };
-} | {
-    type: ACTIONS.INLINE_COMMENT_CLEAR_DIRTY_MARK;
-} | {
-    type: ACTIONS.CLOSE_COMPONENT;
-} | {
-    type: ACTIONS.ADD_INLINE_COMMENT;
-    data: {
-        drafting: boolean;
-        inlineComments: InlineCommentMap;
-        editorState: EditorState;
-        selectedAnnotations: AnnotationInfo[];
-    };
-} | {
-    type: ACTIONS.INLINE_COMMENT_SET_VISIBLE;
-    data: {
-        isVisible: boolean;
-    };
-} | {
-    type: ACTIONS.SET_SELECTED_ANNOTATION;
-    data: {
-        selectedAnnotations: AnnotationInfo[];
-    };
-};
-export type InlineCommentPluginState = {
-    annotations: InlineCommentMap;
-    selectedAnnotations: AnnotationInfo[];
-    dirtyAnnotations?: boolean;
-    mouseData: InlineCommentMouseData;
-    draftDecorationSet?: DecorationSet;
-    bookmark?: SelectionBookmark;
-    disallowOnWhitespace: boolean;
-    isInlineCommentViewClosed: boolean;
-    isVisible: boolean;
-    skipSelectionHandling: boolean;
-};