@atlaskit/editor-core 171.0.1 → 172.0.0

package/dist/esm/ui/Layer/index.js

@@ -0,0 +1,228 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+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 React, { Component } from 'react';
+import rafSchedule from 'raf-schd';
+import Popper from 'popper.js'; // eslint-disable-line import/extensions
+
+import { positionPropToPopperPosition } from './internal/helpers';
+var defaultState = {
+  hasExtractedStyles: false,
+  // We set these default offsets to prevent a flash of popper content in the wrong position
+  // which can cause incorrect height calculations. Popper will calculate these values
+  offsets: {
+    popper: {
+      left: -9999,
+      top: -9999,
+      position: null
+    }
+  },
+  // fix Safari parent width: https://product-fabric.atlassian.net/browse/ED-1784
+  cssPosition: 'absolute',
+  originalHeight: null,
+  maxHeight: null
+};
+
+var Layer = /*#__PURE__*/function (_Component) {
+  _inherits(Layer, _Component);
+
+  var _super = _createSuper(Layer);
+
+  // working with extract-react-types
+  function Layer(props) {
+    var _this;
+
+    _classCallCheck(this, Layer);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "targetRef", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "contentRef", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "extractStyles", function (state) {
+      if (state) {
+        var popperHeight = state.offsets.popper.height;
+        var left = Math.round(state.offsets.popper.left);
+        var top = Math.round(state.offsets.popper.top);
+        var cssPosition = 'absolute';
+        var originalHeight = _this.state.originalHeight || popperHeight;
+
+        var maxHeight = _this.calculateMaxHeight(originalHeight, popperHeight, top, cssPosition);
+
+        _this.setState({
+          // position: fixed or absolute
+          cssPosition: cssPosition,
+          hasExtractedStyles: true,
+          transform: "translate3d(".concat(left, "px, ").concat(top, "px, 0px)"),
+          originalHeight: originalHeight,
+          maxHeight: maxHeight
+        });
+      }
+    });
+
+    _this.state = defaultState;
+    _this.extractStyles = rafSchedule(_this.extractStyles.bind(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  _createClass(Layer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.applyPopper(this.props);
+    }
+  }, {
+    key: "UNSAFE_componentWillReceiveProps",
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      this.applyPopper(nextProps);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      var onPositioned = this.props.onPositioned;
+      var hasExtractedStyles = this.state.hasExtractedStyles; // This flag is set the first time the position is calculated from Popper and applied to the content
+
+      if (!prevState.hasExtractedStyles && hasExtractedStyles && onPositioned) {
+        onPositioned();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      // this.extractStyles.cancel();
+      if (this.popper) {
+        this.popper.destroy();
+      }
+    }
+    /* Calculate the max height of the popper if it's height is greater than the viewport to prevent
+     * the bottom of the popper not being viewable.
+     * Only works if the popper uses viewport as the boundary and has a fixed position ancestor.
+     */
+
+  }, {
+    key: "calculateMaxHeight",
+    value: function calculateMaxHeight(originalHeight, currentHeight, positionTop, cssPosition) {
+      var DocumentElementClientHeight = 0;
+
+      if (document.documentElement) {
+        DocumentElementClientHeight = document.documentElement.clientHeight;
+      }
+
+      if (cssPosition !== 'fixed') {
+        return null;
+      }
+
+      var viewportHeight = Math.max(DocumentElementClientHeight, window.innerHeight || 0);
+      return viewportHeight < originalHeight && currentHeight + positionTop >= viewportHeight - 50 ? // allow some spacing either side of viewport height
+      viewportHeight - 12 : null;
+    }
+  }, {
+    key: "applyPopper",
+    value: function applyPopper(props) {
+      if (!this.targetRef.current || !this.contentRef.current) {
+        return;
+      }
+
+      if (this.popper) {
+        this.popper.destroy();
+      } // "new Popper(...)" operation is very expensive when called on virtual DOM.
+      // This condition reduces the number of calls so we can run our tests faster
+      // (time was reduced from 100s to 13s).
+
+
+      if (!props.content) {
+        return;
+      } // we wrap our target in a div so that we can safely get a reference to it, but we pass the
+      // actual target to popper
+
+
+      var isAlwaysFixed = false;
+      var actualTarget = this.targetRef.current.children[0];
+      var popperOpts = {
+        placement: positionPropToPopperPosition(props.position),
+        onCreate: this.extractStyles,
+        onUpdate: this.extractStyles,
+        modifiers: {
+          applyStyle: {
+            enabled: false
+          },
+          hide: {
+            enabled: false
+          },
+          offset: {
+            enabled: true,
+            offset: this.props.offset
+          },
+          flip: {
+            enabled: false,
+            flipVariations: true,
+            boundariesElement: 'viewport',
+            padding: 0 // leave 0 pixels between popper and the boundariesElement
+
+          },
+          preventOverflow: {
+            enabled: false,
+            escapeWithReference: true
+          }
+        },
+        positionFixed: isAlwaysFixed
+      };
+
+      if (actualTarget) {
+        this.popper = new Popper(actualTarget, this.contentRef.current, popperOpts);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state = this.state,
+          transform = _this$state.transform,
+          hasExtractedStyles = _this$state.hasExtractedStyles,
+          maxHeight = _this$state.maxHeight;
+      var opacity = hasExtractedStyles ? {} : {
+        opacity: 0
+      };
+      return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
+        ref: this.targetRef
+      }, this.props.children), /*#__PURE__*/React.createElement("div", {
+        ref: this.contentRef,
+        style: _objectSpread({
+          top: 0,
+          left: 0,
+          position: 'absolute',
+          transform: transform,
+          maxHeight: maxHeight ? maxHeight : 'auto'
+        }, opacity)
+      }, this.props.content));
+    }
+  }]);
+
+  return Layer;
+}(Component);
+
+_defineProperty(Layer, "defaultProps", {
+  boundariesElement: 'viewport',
+  children: null,
+  content: null,
+  offset: '0, 0',
+  position: 'right middle',
+  zIndex: 400,
+  lockScroll: false,
+  isAlwaysFixed: false,
+  onPositioned: function onPositioned() {}
+});
+
+export { Layer as default };

package/dist/esm/ui/Layer/internal/helpers.js

@@ -0,0 +1,62 @@
+var positionMap = {
+  'top left': {
+    position: 'top-start',
+    animation: 'top'
+  },
+  'top center': {
+    position: 'top',
+    animation: 'top'
+  },
+  'top right': {
+    position: 'top-end',
+    animation: 'top'
+  },
+  'right top': {
+    position: 'right-start',
+    animation: 'right'
+  },
+  'right middle': {
+    position: 'right',
+    animation: 'right'
+  },
+  'right bottom': {
+    position: 'right-end',
+    animation: 'right'
+  },
+  'bottom left': {
+    position: 'bottom-start',
+    animation: 'bottom'
+  },
+  'bottom center': {
+    position: 'bottom',
+    animation: 'bottom'
+  },
+  'bottom right': {
+    position: 'bottom-end',
+    animation: 'bottom'
+  },
+  'left top': {
+    position: 'left-start',
+    animation: 'left'
+  },
+  'left middle': {
+    position: 'left',
+    animation: 'left'
+  },
+  'left bottom': {
+    position: 'left-end',
+    animation: 'left'
+  }
+};
+export var POSITION_ATTRIBUTE_ENUM = {
+  values: ['top left', 'top center', 'top right', 'right top', 'right middle', 'right bottom', 'bottom left', 'bottom center', 'bottom right', 'left top', 'left middle', 'left bottom'],
+  default: 'right middle'
+};
+
+function positionToPopper(position) {
+  return position && positionMap[position] ? positionMap[position].position : null;
+}
+
+export function positionPropToPopperPosition(position) {
+  return positionToPopper(position) || positionMap[POSITION_ATTRIBUTE_ENUM.default].position;
+}

package/dist/esm/ui/PortalProvider/index.js

@@ -55,37 +55,18 @@ export var PortalProviderAPI = /*#__PURE__*/function (_EventDispatcher) {
       var hasAnalyticsContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       var hasIntlContext = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
-      if (this.themeMode) {
-        var childrenWithThemeProviders = function childrenWithThemeProviders() {
-          return /*#__PURE__*/React.createElement(PortalProviderThemeProviders, {
-            mode: _this2.themeMode
-          }, children());
-        };
-
-        this.portals.set(container, {
-          children: childrenWithThemeProviders,
-          hasAnalyticsContext: hasAnalyticsContext,
-          hasIntlContext: hasIntlContext
-        });
-
-        var _wrappedChildren = this.useAnalyticsContext ? /*#__PURE__*/React.createElement(AnalyticsContextWrapper, null, childrenWithThemeProviders()) : childrenWithThemeProviders();
-
-        if (hasIntlContext) {
-          _wrappedChildren = /*#__PURE__*/React.createElement(RawIntlProvider, {
-            value: this.intl
-          }, _wrappedChildren);
-        }
-
-        unstable_renderSubtreeIntoContainer(this.context, _wrappedChildren, container);
-        return;
-      }
+      var childrenWithThemeProviders = function childrenWithThemeProviders() {
+        return /*#__PURE__*/React.createElement(PortalProviderThemeProviders, {
+          mode: _this2.themeMode
+        }, children());
+      };
 
       this.portals.set(container, {
-        children: children,
+        children: childrenWithThemeProviders,
         hasAnalyticsContext: hasAnalyticsContext,
         hasIntlContext: hasIntlContext
       });
-      var wrappedChildren = this.useAnalyticsContext ? /*#__PURE__*/React.createElement(AnalyticsContextWrapper, null, children()) : children();
+      var wrappedChildren = this.useAnalyticsContext ? /*#__PURE__*/React.createElement(AnalyticsContextWrapper, null, childrenWithThemeProviders()) : childrenWithThemeProviders();
 
       if (hasIntlContext) {
         wrappedChildren = /*#__PURE__*/React.createElement(RawIntlProvider, {

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/editor-core";
-export var version = "171.0.1";
+export var version = "172.0.0";
 export var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/esm/version.json

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

package/dist/types/labs/next/presets/default.d.ts

@@ -15,6 +15,7 @@ import { CodeBlockOptions } from '../../../plugins/code-block/types';
 import { SelectionPluginOptions } from '../../../plugins/selection/types';
 import { CardOptions } from '@atlaskit/editor-common/card';
 import { TypeAheadPluginOptions } from '../../../plugins/type-ahead';
+import { HyperlinkPluginOptions } from '../../../plugins/hyperlink/types';
 interface EditorPresetDefaultProps {
     children?: React.ReactNode;
 }
@@ -30,6 +31,7 @@ export declare type DefaultPresetPluginOptions = {
     codeBlock?: CodeBlockOptions;
     selection?: SelectionPluginOptions;
     cardOptions?: CardOptions;
+    hyperlinkOptions?: HyperlinkPluginOptions;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
     typeAhead?: TypeAheadPluginOptions;
 };

package/dist/types/plugins/analytics/plugin.d.ts

@@ -7,5 +7,9 @@ interface AnalyticsPluginOptions {
     performanceTracking?: PerformanceTracking;
 }
 declare const analyticsPlugin: (options: AnalyticsPluginOptions) => EditorPlugin;
-export declare function extendPayload(payload: AnalyticsEventPayload, duration: number): AnalyticsEventPayload<void>;
+export declare function extendPayload({ payload, duration, distortedDuration, }: {
+    payload: AnalyticsEventPayload;
+    duration: number;
+    distortedDuration: boolean;
+}): AnalyticsEventPayload<void>;
 export default analyticsPlugin;

package/dist/types/plugins/analytics/types/cut-copy-events.d.ts

@@ -2,6 +2,8 @@ import { TrackAEP } from './utils';
 import { ACTION, ACTION_SUBJECT } from './enums';
 declare type CopyAEP = TrackAEP<ACTION.COPIED, ACTION_SUBJECT.DOCUMENT, undefined, {
     content: string[];
+    inputMethod?: string;
+    nodeType?: string;
 }, undefined>;
 declare type CutAEP = TrackAEP<ACTION.CUT, ACTION_SUBJECT.DOCUMENT, undefined, {
     content: string[];

package/dist/types/plugins/analytics/types/general-events.d.ts

@@ -41,6 +41,7 @@ declare type EditorPerfAEP = OperationalAEPWithObjectId<ACTION.EDITOR_MOUNTED |
     nodes?: Record<string, number>;
     ttfb?: number;
     severity?: SEVERITY;
+    distortedDuration?: boolean;
 }, undefined>;
 declare type EditorTTIAEP = OperationalAEP<ACTION.EDITOR_TTI, ACTION_SUBJECT.EDITOR, undefined, {
     tti: number;

package/dist/types/plugins/analytics/types/paste-events.d.ts

@@ -33,6 +33,7 @@ declare type PastedTimedAEP = PasteBaseOperationalAEP<ACTION.PASTED_TIMED, {
     pasteIntoNode: PASTE_ACTION_SUBJECT_ID;
     content: Array<string>;
     time: number;
+    distortedDuration: boolean;
 }, undefined>;
 export declare type PasteEventPayload = PasteAEP | PasteAsPlainAEP | PastedTimedAEP;
 export {};

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

@@ -8,6 +8,6 @@ export interface BasePluginOptions {
     browserFreezeTracking?: BrowserFreezetracking;
     ufo?: boolean;
 }
-export declare const isChromeWithSelectionBug: boolean;
+export declare const isChromeWithSelectionBug: any;
 declare const basePlugin: (options?: BasePluginOptions | undefined) => EditorPlugin;
 export default basePlugin;

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

@@ -1,9 +1,4 @@
 import { EditorPlugin } from '../../types';
-import { CardOptions } from '@atlaskit/editor-common/card';
-import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
-declare const cardPlugin: (options: CardOptions & {
-    platform: 'mobile' | 'web';
-    fullWidthMode?: boolean;
-    createAnalyticsEvent?: CreateUIAnalyticsEvent;
-}) => EditorPlugin;
+import { CardPluginOptions } from './types';
+declare const cardPlugin: (options: CardPluginOptions) => EditorPlugin;
 export default cardPlugin;

package/dist/types/plugins/card/nodeviews/genericCard.d.ts

@@ -2,7 +2,8 @@ import React from 'react';
 import { Node as PMNode } from 'prosemirror-model';
 import { EditorView } from 'prosemirror-view';
 import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
-import { Context as SmartCardContext, CardPlatform } from '@atlaskit/smart-card';
+import { CardPlatform } from '@atlaskit/smart-card';
+import { SmartCardContext } from '@atlaskit/link-provider';
 import { getPosHandler, ReactComponentProps } from '../../../nodeviews';
 import { EventDispatcher } from '../../../event-dispatcher';
 import { DispatchAnalyticsEvent } from '../../../plugins/analytics';

package/dist/types/plugins/card/toolbar.d.ts

@@ -1,9 +1,7 @@
-import { IntlShape } from 'react-intl-next';
-import { EditorState } from 'prosemirror-state';
 import { Command } from '../../types';
-import { FloatingToolbarConfig } from '../floating-toolbar/types';
+import { FloatingToolbarHandler } from '../floating-toolbar/types';
 import { CardOptions } from '@atlaskit/editor-common/card';
-import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { LinkPickerOptions } from '../hyperlink/types';
 export declare const removeCard: Command;
 export declare const visitCardLink: Command;
-export declare const floatingToolbar: (cardOptions: CardOptions, platform?: import("json-ld-types").JsonLd.Primitives.Platforms | undefined) => (state: EditorState, intl: IntlShape, providerFactory: ProviderFactory) => FloatingToolbarConfig | undefined;
+export declare const floatingToolbar: (cardOptions: CardOptions, platform?: import("json-ld-types").JsonLd.Primitives.Platforms | undefined, linkPickerOptions?: LinkPickerOptions | undefined) => FloatingToolbarHandler;

package/dist/types/plugins/card/types.d.ts

@@ -3,6 +3,7 @@ import { CardProvider, CardAppearance, CardAdf } from '@atlaskit/editor-common/p
 import { SmartLinkEvents } from '@atlaskit/smart-card';
 import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { CardOptions } from '@atlaskit/editor-common/card';
+import { LinkPickerOptions } from '../hyperlink/types';
 export declare type CardInfo = {
     title?: string;
     url?: string;
@@ -32,6 +33,7 @@ export declare type CardPluginOptions = CardOptions & {
     platform: 'mobile' | 'web';
     fullWidthMode?: boolean;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    linkPicker?: LinkPickerOptions;
 };
 export declare type SetProvider = {
     type: 'SET_PROVIDER';

package/dist/types/plugins/card/ui/EditLinkToolbar.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { EditorView } from 'prosemirror-view';
 import { Node } from 'prosemirror-model';
 import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { LinkPickerOptions } from '../../hyperlink/types';
 import { Command } from '../../../types';
 import { FloatingToolbarItem, FloatingToolbarConfig } from '../../floating-toolbar/types';
 export declare type EditLinkToolbarProps = {
@@ -11,6 +12,7 @@ export declare type EditLinkToolbarProps = {
     text: string;
     node: Node;
     onSubmit?: (href: string, text?: string) => void;
+    linkPickerOptions?: LinkPickerOptions;
 };
 export declare class EditLinkToolbar extends React.Component<EditLinkToolbarProps> {
     componentDidUpdate(prevProps: EditLinkToolbarProps): void;
@@ -19,8 +21,9 @@ export declare class EditLinkToolbar extends React.Component<EditLinkToolbarProp
     render(): JSX.Element;
 }
 export declare const editLink: Command;
-export declare const buildEditLinkToolbar: ({ providerFactory, node, }: {
+export declare const buildEditLinkToolbar: ({ providerFactory, node, linkPicker, }: {
     providerFactory: ProviderFactory;
     node: Node;
+    linkPicker?: LinkPickerOptions | undefined;
 }) => FloatingToolbarItem<Command>;
 export declare const editLinkToolbarConfig: Partial<FloatingToolbarConfig>;

package/dist/types/plugins/card/ui/LinkToolbarAppearance.d.ts

@@ -2,7 +2,8 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { IntlShape } from 'react-intl-next';
 import { EditorState } from 'prosemirror-state';
-import { CardContext, CardPlatform } from '@atlaskit/smart-card';
+import { CardPlatform } from '@atlaskit/smart-card';
+import { CardContext } from '@atlaskit/link-provider';
 import { EditorView } from 'prosemirror-view';
 import { CardAppearance } from '@atlaskit/editor-common/provider-factory';
 export interface LinkToolbarAppearanceProps {

package/dist/types/plugins/clipboard/pm-plugins/main.d.ts

@@ -1,7 +1,9 @@
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { EditorState } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
 import { PMPluginFactoryParams } from '../../../types';
 import { DispatchAnalyticsEvent } from '../../analytics/types/dispatch-analytics-event';
+import { AnalyticsEventPayload } from '../../../plugins/analytics';
 import { ACTION } from '../../analytics/types/enums';
 import { DOMSerializer } from 'prosemirror-model';
 import type { Schema } from 'prosemirror-model';
@@ -14,3 +16,4 @@ export declare const createPlugin: ({ dispatchAnalyticsEvent, schema, }: PMPlugi
  */
 export declare const createClipboardSerializer: (schema: Schema, getEditorView: () => EditorView) => DOMSerializer;
 export declare const sendClipboardAnalytics: (view: EditorView, dispatchAnalyticsEvent: DispatchAnalyticsEvent, action: ACTION.CUT | ACTION.COPIED) => boolean;
+export declare const getAnalyticsPayload: (state: EditorState, action: ACTION.CUT | ACTION.COPIED) => AnalyticsEventPayload | undefined;

package/dist/types/plugins/code-block/nodeviews/code-block.d.ts

@@ -18,4 +18,4 @@ export declare class CodeBlockView {
         target: Element;
     }): boolean;
 }
-export declare const codeBlockNodeView: () => (node: Node, view: EditorView, getPos: getPosHandler) => CodeBlockView;
+export declare const codeBlockNodeView: (node: Node, view: EditorView, getPos: getPosHandler) => CodeBlockView;

package/dist/types/plugins/code-block/pm-plugins/codeBlockCopySelectionPlugin.d.ts

@@ -0,0 +1,11 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import type { EditorState, Transaction } from 'prosemirror-state';
+export declare const copySelectionPluginKey: PluginKey<any, any>;
+declare type CodeBlockCopySelectionPluginState = {
+    decorationStartAndEnd?: [start: number, end: number];
+};
+export declare function codeBlockCopySelectionPlugin(): SafePlugin<CodeBlockCopySelectionPluginState, any>;
+export declare function provideVisualFeedbackForCopyButton(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+export declare function removeVisualFeedbackForCopyButton(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+export {};

package/dist/types/plugins/code-block/styles.d.ts

@@ -1,3 +1,2 @@
 import { ThemeProps } from '@atlaskit/theme/types';
-export declare const highlightingCodeBlockStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
 export declare const codeBlockStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;

package/dist/types/plugins/code-block/ui/class-names.d.ts

@@ -1,5 +1,4 @@
 export declare const codeBlockClassNames: {
     gutter: string;
     content: string;
-    highlighting: string;
 };

package/dist/types/plugins/copy-button/commands.d.ts

@@ -1,4 +1,4 @@
 import { Command } from '../../types';
 import { NodeType } from 'prosemirror-model';
-export declare const copy: (nodeType: NodeType) => Command;
-export declare const resetCopiedState: (nodeType: NodeType, onMouseLeave?: Command | undefined) => Command;
+export declare const createToolbarCopyCommand: (nodeType: NodeType | Array<NodeType>) => Command;
+export declare const resetCopiedState: (nodeType: NodeType | Array<NodeType>, onMouseLeave?: Command | undefined) => Command;

package/dist/types/plugins/copy-button/toolbar.d.ts

@@ -0,0 +1,7 @@
+import { NodeType } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { IntlShape } from 'react-intl-next';
+import { Command } from '../../../src/types';
+import { FloatingToolbarItem } from '../floating-toolbar/types';
+export declare const getCopyButtonConfig: (state: EditorState, formatMessage: IntlShape['formatMessage'], nodeType: NodeType | Array<NodeType>, onMouseEnter?: Command | undefined, onMouseLeave?: Command | undefined) => FloatingToolbarItem<Command>;
+export declare const showCopyButton: (state?: EditorState<any> | undefined) => import("prosemirror-state").Plugin<any, any> | undefined;

package/dist/types/plugins/copy-button/utils.d.ts

@@ -1,7 +1,8 @@
 import { NodeType } from 'prosemirror-model';
-import { EditorState } from 'prosemirror-state';
-import { IntlShape } from 'react-intl-next';
-import { Command } from '../../../src/types';
-import { FloatingToolbarItem } from '../floating-toolbar/types';
-export declare const getCopyButtonConfig: (state: EditorState, formatMessage: IntlShape['formatMessage'], nodeType: NodeType, onMouseEnter?: Command | undefined, onMouseLeave?: Command | undefined) => FloatingToolbarItem<Command>;
-export declare const showCopyButton: (state?: EditorState<any> | undefined) => import("prosemirror-state").Plugin<any, any> | undefined;
+import { Schema, Node as PMNode } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+export declare function getSelectedNodeOrNodeParentByNodeType({ nodeType, selection, }: {
+    nodeType: NodeType | Array<NodeType>;
+    selection: Transaction['selection'];
+}): import("prosemirror-utils").ContentNodeWithPos | undefined;
+export declare const toDOM: (node: PMNode, schema: Schema) => Node;

package/dist/types/plugins/floating-toolbar/types.d.ts

@@ -10,7 +10,6 @@ import { SelectOption } from './ui/Select';
 import React from 'react';
 import { DropdownOptions, RenderOptionsPropsT } from './ui/types';
 import { DispatchAnalyticsEvent } from '../analytics/types/dispatch-analytics-event';
-import { CardOptions } from '@atlaskit/editor-common/card';
 import { PaletteColor } from '../../ui/ColorPalette/Palettes/type';
 import { EmojiId } from '@atlaskit/emoji/types';
 export declare type Icon = React.ComponentType<{
@@ -150,5 +149,5 @@ export interface FloatingToolbarConfig {
     forcePlacement?: boolean;
     onPositionCalculated?: (editorView: EditorView, nextPos: Position) => Position;
 }
-export declare type FloatingToolbarHandler = (state: EditorState, intl: IntlShape, providerFactory: ProviderFactory, cardOptions?: CardOptions) => FloatingToolbarConfig | undefined;
+export declare type FloatingToolbarHandler = (state: EditorState, intl: IntlShape, providerFactory: ProviderFactory) => FloatingToolbarConfig | undefined;
 export {};

package/dist/types/plugins/hyperlink/Toolbar.d.ts

@@ -1,2 +1,3 @@
 import { FloatingToolbarHandler } from '../floating-toolbar/types';
-export declare const getToolbarConfig: FloatingToolbarHandler;
+import { HyperlinkPluginOptions } from './types';
+export declare const getToolbarConfig: (options?: HyperlinkPluginOptions | undefined) => FloatingToolbarHandler;

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

@@ -1,5 +1,5 @@
 import { EditorPlugin } from '../../types';
-import { CardOptions } from '@atlaskit/editor-common/card';
-declare const hyperlinkPlugin: (options?: CardOptions | undefined) => EditorPlugin;
+import { HyperlinkPluginOptions } from './types';
+declare const hyperlinkPlugin: (options?: HyperlinkPluginOptions | undefined) => EditorPlugin;
 export type { HyperlinkState } from './pm-plugins/main';
 export default hyperlinkPlugin;