@atlaskit/editor-plugin-selection 0.1.0

package/dist/esm/utils.js

@@ -0,0 +1,241 @@
+import { createSelectionClickHandler, getAllSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, getNodeSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, isIgnored as isIgnoredByGapCursor, isSelectionAtEndOfNode, isSelectionAtStartOfNode } from '@atlaskit/editor-common/selection';
+import { isEmptyParagraph } from '@atlaskit/editor-common/utils';
+import { AllSelection, NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findParentNode, flatten } from '@atlaskit/editor-prosemirror/utils';
+import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { akEditorSelectedNodeClassName } from '@atlaskit/editor-shared-styles';
+import { selectionPluginKey } from './types';
+export var getDecorations = function getDecorations(tr) {
+  if (tr.selection instanceof NodeSelection) {
+    return DecorationSet.create(tr.doc, [Decoration.node(tr.selection.from, tr.selection.to, {
+      class: akEditorSelectedNodeClassName
+    })]);
+  }
+  if (tr.selection instanceof TextSelection || tr.selection instanceof AllSelection) {
+    var decorations = getNodesToDecorateFromSelection(tr.selection, tr.doc).map(function (_ref) {
+      var node = _ref.node,
+        pos = _ref.pos;
+      return Decoration.node(pos, pos + node.nodeSize, {
+        class: akEditorSelectedNodeClassName
+      });
+    });
+    return DecorationSet.create(tr.doc, decorations);
+  }
+  return DecorationSet.empty;
+};
+var topLevelBlockNodesThatHaveSelectionStyles = ['table', 'panel', 'expand', 'layoutSection', 'decisionList', 'decisionItem', 'codeBlock'];
+
+/**
+ * Use `getNodesToDecorateFromSelection` to collect and return
+ * a list of nodes within the Selection that should have Selection
+ * decorations applied. This allows selection styles to be added to
+ * nested nodes. It will ignore text nodes as decorations are
+ * applied natively and also ignore nodes that don't completely
+ * sit within the given `Selection`.
+ */
+export var getNodesToDecorateFromSelection = function getNodesToDecorateFromSelection(selection, doc) {
+  var nodes = [];
+  if (selection.from !== selection.to) {
+    var from = selection.from,
+      to = selection.to;
+    doc.nodesBetween(from, to, function (node, pos) {
+      var withinSelection = from <= pos && pos + node.nodeSize <= to;
+      // The reason we need to check for these nodes is to stop
+      // traversing their children if they are within a selection -
+      // this is to prevent selection styles from being added to
+      // the children as well as the parent node.
+      // Example scenario is if an entire table has been selected
+      // we should not traverse its children so we can apply the
+      // selection styles to the table. But if an entire tableRow
+      // has been selected (but the parent table has not) we should
+      // traverse it as it could contain other nodes that need
+      // selection styles. I couldn’t see a clear way to differentiate
+      // without explicitly stating which nodes should be traversed
+      // and which shouldn’t.
+      var isTopLevelNodeThatHasSelectionStyles = topLevelBlockNodesThatHaveSelectionStyles.includes(node.type.name);
+      // If the node is a top-level block node and completely sits within
+      // the selection, we do not recurse it's children to prevent selection
+      // styles being added to its child nodes. The expected behaviour
+      // is that selection styles are only added to the parent.
+      if (node && withinSelection && isTopLevelNodeThatHasSelectionStyles) {
+        nodes.push({
+          node: node,
+          pos: pos
+        });
+        return false;
+        // Otherwise we recurse the children and return them so we can apply
+        // selection styles. Text is handled by the browser.
+      } else if (node && withinSelection && !node.isText) {
+        nodes.push({
+          node: node,
+          pos: pos
+        });
+      }
+      return true;
+    });
+  }
+  return nodes;
+};
+export function shouldRecalcDecorations(_ref2) {
+  var oldEditorState = _ref2.oldEditorState,
+    newEditorState = _ref2.newEditorState;
+  var oldSelection = oldEditorState.selection;
+  var newSelection = newEditorState.selection;
+  var oldPluginState = selectionPluginKey.getState(oldEditorState);
+  var newPluginState = selectionPluginKey.getState(newEditorState);
+  if (!oldPluginState || !newPluginState) {
+    return false;
+  }
+
+  // If selection is unchanged, no need to recalculate
+  if (oldSelection.eq(newSelection)) {
+    // We need this special case for NodeSelection, as Prosemirror still thinks the
+    // selections are equal when the node has changed
+    if (oldSelection instanceof NodeSelection && newSelection instanceof NodeSelection) {
+      var oldDecorations = oldPluginState.decorationSet.find();
+      var newDecorations = newPluginState.decorationSet.find();
+      // There might not be old or new decorations if the node selection is for a text node
+      // This wouldn't have happened intentionally, but we need to handle this case regardless
+      if (oldDecorations.length > 0 && newDecorations.length > 0) {
+        return !oldDecorations[0].eq(newDecorations[0]);
+      }
+      return !(oldDecorations.length === 0 && newDecorations.length === 0);
+    }
+    return false;
+  }
+
+  // There's no point updating decorations if going from one standard TextSelection to another
+  if (oldSelection instanceof TextSelection && newSelection instanceof TextSelection && oldSelection.from === oldSelection.to && newSelection.from === newSelection.to) {
+    return false;
+  }
+  return true;
+}
+export var isSelectableContainerNode = function isSelectableContainerNode(node) {
+  return !!(node && !node.isAtom && NodeSelection.isSelectable(node));
+};
+export var isSelectableChildNode = function isSelectableChildNode(node) {
+  return !!(node && (node.isText || isEmptyParagraph(node) || NodeSelection.isSelectable(node)));
+};
+
+/**
+ * Finds closest parent node that is a selectable block container node
+ * If it finds a parent that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+export var findSelectableContainerParent = function findSelectableContainerParent(selection) {
+  var foundNodeThatSupportsGapCursor = false;
+  var selectableNode = findParentNode(function (node) {
+    var isSelectable = isSelectableContainerNode(node);
+    if (!isSelectable && !isIgnoredByGapCursor(node)) {
+      foundNodeThatSupportsGapCursor = true;
+    }
+    return isSelectable;
+  })(selection);
+  if (!foundNodeThatSupportsGapCursor) {
+    return selectableNode;
+  }
+};
+
+/**
+ * Finds node before that is a selectable block container node, starting
+ * from $pos.depth + 1 and working in
+ * If it finds a node that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+export var findSelectableContainerBefore = function findSelectableContainerBefore($pos, doc) {
+  // prosemirror just returns the same pos from Selection.findFrom when
+  // parent.inlineContent is true, so we move position back one here
+  // to counteract that
+  if ($pos.parent.inlineContent && isSelectableContainerNode($pos.parent)) {
+    $pos = doc.resolve($pos.start() - 1);
+  }
+  var selectionBefore = Selection.findFrom($pos, -1);
+  if (selectionBefore) {
+    var $selectionBefore = doc.resolve(selectionBefore.from);
+    for (var i = $pos.depth + 1; i <= $selectionBefore.depth; i++) {
+      var node = $selectionBefore.node(i);
+      if (isSelectableContainerNode(node)) {
+        return {
+          node: node,
+          pos: $selectionBefore.start(i) - 1
+        };
+      }
+      if (i > $pos.depth + 1 && !isIgnoredByGapCursor(node)) {
+        return;
+      }
+    }
+
+    /**
+     * Stick to the default left selection behaviour,
+     * useful for mediaSingleWithCaption
+     */
+    if (selectionBefore instanceof NodeSelection && NodeSelection.isSelectable(selectionBefore.node)) {
+      return {
+        node: selectionBefore.node,
+        pos: selectionBefore.from
+      };
+    }
+  }
+};
+
+/**
+ * Finds node after that is a selectable block container node, starting
+ * from $pos.depth + 1 and working in
+ * If it finds a node that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+export var findSelectableContainerAfter = function findSelectableContainerAfter($pos, doc) {
+  var selectionAfter = Selection.findFrom($pos, 1);
+  if (selectionAfter) {
+    var $selectionAfter = doc.resolve(selectionAfter.from);
+    for (var i = $pos.depth + 1; i <= $selectionAfter.depth; i++) {
+      var node = $selectionAfter.node(i);
+      if (isSelectableContainerNode(node)) {
+        return {
+          node: node,
+          pos: $selectionAfter.start(i) - 1
+        };
+      }
+      if (i > $pos.depth + 1 && !isIgnoredByGapCursor(node)) {
+        return;
+      }
+    }
+  }
+};
+
+/**
+ * Finds first child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+export var findFirstChildNodeToSelect = function findFirstChildNodeToSelect(parent) {
+  return flatten(parent).find(function (child) {
+    return isSelectableChildNode(child.node) || !isIgnoredByGapCursor(child.node);
+  });
+};
+
+/**
+ * Finds last child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+export var findLastChildNodeToSelect = function findLastChildNodeToSelect(parent) {
+  var child;
+  parent.descendants(function (node, pos) {
+    if (isSelectableChildNode(node) || !isIgnoredByGapCursor(node)) {
+      child = {
+        node: node,
+        pos: pos
+      };
+      return false;
+    }
+  });
+  if (child) {
+    return child;
+  }
+};
+export var isSelectionAtStartOfParentNode = function isSelectionAtStartOfParentNode($pos, selection) {
+  return isSelectionAtStartOfNode($pos, findSelectableContainerParent(selection));
+};
+export var isSelectionAtEndOfParentNode = function isSelectionAtEndOfParentNode($pos, selection) {
+  return isSelectionAtEndOfNode($pos, findSelectableContainerParent(selection));
+};
+export { getNodeSelectionAnalyticsPayload, getAllSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, createSelectionClickHandler };

package/dist/types/actions.d.ts

@@ -0,0 +1,17 @@
+import type { Selection } from '@atlaskit/editor-prosemirror/state';
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { RelativeSelectionPos } from './types';
+export declare enum SelectionActionTypes {
+    SET_DECORATIONS = "SET_DECORATIONS",
+    SET_RELATIVE_SELECTION = "SET_RELATIVE_SELECTION"
+}
+export interface SetDecorations {
+    type: SelectionActionTypes.SET_DECORATIONS;
+    decorationSet: DecorationSet;
+    selection: Selection;
+}
+export interface SetRelativeSelection {
+    type: SelectionActionTypes.SET_RELATIVE_SELECTION;
+    selectionRelativeToNode?: RelativeSelectionPos;
+}
+export type SelectionAction = SetDecorations | SetRelativeSelection;

package/dist/types/commands.d.ts

@@ -0,0 +1,9 @@
+import type { Command, EditorCommandWithMetadata } from '@atlaskit/editor-common/types';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { RelativeSelectionPos } from './types';
+export declare const selectNearNode: EditorCommandWithMetadata;
+export declare const setSelectionRelativeToNode: (selectionRelativeToNode?: RelativeSelectionPos, selection?: Selection | null) => Command;
+export declare const arrowRight: Command;
+export declare const arrowLeft: Command;
+export declare const setSelectionInsideAtNodeEnd: (selectionRelativeToNode: RelativeSelectionPos, node: PmNode, from: number, to: number) => Command;

package/dist/types/gap-cursor/actions.d.ts

@@ -0,0 +1,23 @@
+import type { Command } from '@atlaskit/editor-common/types';
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Direction } from './direction';
+export type DirectionString = 'up' | 'down' | 'left' | 'right' | 'forward' | 'backward';
+export declare const shouldSkipGapCursor: (direction: Direction, state: EditorState, $pos: ResolvedPos) => boolean;
+export declare const arrow: (dir: Direction, endOfTextblock?: ((dir: DirectionString, state?: EditorState) => boolean) | undefined) => Command;
+export declare const deleteNode: (dir: Direction) => Command;
+export declare const setSelectionTopLevelBlocks: (tr: Transaction, event: React.MouseEvent<any>, editorRef: HTMLElement, posAtCoords: (coords: {
+    left: number;
+    top: number;
+}) => {
+    pos: number;
+    inside: number;
+} | null | void, editorFocused: boolean) => void;
+export declare const setCursorForTopLevelBlocks: (event: React.MouseEvent<any>, editorRef: HTMLElement, posAtCoords: (coords: {
+    left: number;
+    top: number;
+}) => {
+    pos: number;
+    inside: number;
+} | null | void, editorFocused: boolean) => Command;
+export declare const hasGapCursorPlugin: (state: EditorState) => boolean;

package/dist/types/gap-cursor/direction.d.ts

@@ -0,0 +1,10 @@
+export declare enum Direction {
+    UP = "up",
+    RIGHT = "right",
+    DOWN = "down",
+    LEFT = "left",
+    BACKWARD = "backward",
+    FORWARD = "forward"
+}
+export declare function isBackward(dir: Direction): boolean;
+export declare function isForward(dir: Direction): boolean;

package/dist/types/gap-cursor/selection.d.ts

@@ -0,0 +1 @@
+export { GapCursorSelection, JSON_ID, Side, GapBookmark, } from '@atlaskit/editor-common/selection';

package/dist/types/gap-cursor/utils/is-ignored.d.ts

@@ -0,0 +1 @@
+export { isIgnored } from '@atlaskit/editor-common/selection';

package/dist/types/gap-cursor/utils/is-valid-target-node.d.ts

@@ -0,0 +1 @@
+export { isValidTargetNode } from '@atlaskit/editor-common/selection';

package/dist/types/gap-cursor/utils/place-gap-cursor.d.ts

@@ -0,0 +1,2 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const toDOM: (view: EditorView, getPos: () => number | undefined) => HTMLSpanElement;

package/dist/types/gap-cursor/utils.d.ts

@@ -0,0 +1,8 @@
+import type { Node as PMNode, ResolvedPos, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Side } from './selection';
+export declare const isLeftCursor: (side: Side) => side is Side.LEFT;
+export declare function getMediaNearPos(doc: PMNode, $pos: ResolvedPos, schema: Schema, dir?: number): PMNode | null;
+export declare const isTextBlockNearPos: (doc: PMNode, schema: Schema, $pos: ResolvedPos, dir: number) => boolean;
+export declare function getLayoutModeFromTargetNode(node: PMNode): string;
+export declare const isIgnoredClick: (elem: HTMLElement) => boolean;
+export declare const getComputedStyleForLayoutMode: (dom: HTMLElement, node: PMNode | undefined | null, style: CSSStyleDeclaration) => CSSStyleDeclaration;

package/dist/types/gap-cursor-selection.d.ts

@@ -0,0 +1,2 @@
+export { GapCursorSelection, Side } from '@atlaskit/editor-common/selection';
+export { setCursorForTopLevelBlocks, setSelectionTopLevelBlocks, hasGapCursorPlugin, } from './gap-cursor/actions';

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { selectionPlugin } from './plugin';
+export type { SelectionPlugin } from './plugin';
+export type { EditorSelectionAPI, SetSelectionRelativeToNode } from './types';

package/dist/types/plugin-factory.d.ts

@@ -0,0 +1,2 @@
+import type { SelectionPluginState } from './types';
+export declare const createCommand: <A = import("./actions").SelectionAction>(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, getPluginState: (state: import("prosemirror-state").EditorState) => SelectionPluginState, createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: SelectionPluginState | ((state: import("prosemirror-state").EditorState) => SelectionPluginState)) => import("prosemirror-state").SafeStateField<SelectionPluginState>;

package/dist/types/plugin.d.ts

@@ -0,0 +1,13 @@
+import type { SelectionSharedState } from '@atlaskit/editor-common/selection';
+import type { EditorCommand, NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { EditorSelectionAPI, SelectionPluginOptions } from './types';
+export type SelectionPlugin = NextEditorPlugin<'selection', {
+    pluginConfiguration: SelectionPluginOptions | undefined;
+    actions: EditorSelectionAPI;
+    commands: {
+        displayGapCursor: (toggle: boolean) => EditorCommand;
+    };
+    sharedState: SelectionSharedState;
+}>;
+export declare const selectionPlugin: SelectionPlugin;
+export default selectionPlugin;

package/dist/types/pm-plugins/events/create-selection-between.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const onCreateSelectionBetween: (view: EditorView, $anchor: ResolvedPos, $head: ResolvedPos) => TextSelection | null;

package/dist/types/pm-plugins/events/keydown.d.ts

@@ -0,0 +1,2 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const onKeydown: (view: EditorView, event: Event) => boolean;

package/dist/types/pm-plugins/gap-cursor-keymap.d.ts

@@ -0,0 +1,2 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export default function keymapPlugin(): SafePlugin;

package/dist/types/pm-plugins/gap-cursor-main.d.ts

@@ -0,0 +1,6 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare const plugin: SafePlugin<{
+    selectionIsGapCursor: boolean;
+    displayGapCursor: boolean;
+}>;
+export default plugin;

package/dist/types/pm-plugins/gap-cursor-plugin-key.d.ts

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const gapCursorPluginKey: PluginKey<any>;

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

@@ -0,0 +1,3 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare function keymapPlugin(): SafePlugin<any>;
+export default keymapPlugin;

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

@@ -0,0 +1,7 @@
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { SelectionPluginOptions, SelectionPluginState } from '../types';
+export declare const getInitialState: (state: EditorState) => SelectionPluginState;
+export declare const createPlugin: (dispatch: Dispatch, dispatchAnalyticsEvent: DispatchAnalyticsEvent, options?: SelectionPluginOptions) => SafePlugin<SelectionPluginState>;

package/dist/types/reducer.d.ts

@@ -0,0 +1,3 @@
+import type { SelectionAction } from './actions';
+import type { SelectionPluginState } from './types';
+export declare function reducer(pluginState: SelectionPluginState, action: SelectionAction): SelectionPluginState;

package/dist/types/types.d.ts

@@ -0,0 +1,20 @@
+import { RelativeSelectionPos } from '@atlaskit/editor-common/selection';
+export type { SelectionPluginState } from '@atlaskit/editor-common/selection';
+import type { LongPressSelectionPluginOptions } from '@atlaskit/editor-common/types';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { EditorState, Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const selectionPluginKey: PluginKey<any>;
+export { RelativeSelectionPos };
+export declare enum SelectionDirection {
+    Before = -1,
+    After = 1
+}
+export type SetSelectionRelativeToNode = (props: {
+    selectionRelativeToNode?: RelativeSelectionPos;
+    selection?: Selection | null;
+}) => (state: EditorState) => Transaction;
+export type EditorSelectionAPI = {
+    selectNearNode: SetSelectionRelativeToNode;
+};
+export interface SelectionPluginOptions extends LongPressSelectionPluginOptions {
+}

package/dist/types/utils.d.ts

@@ -0,0 +1,58 @@
+import { createSelectionClickHandler, getAllSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, getNodeSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload } from '@atlaskit/editor-common/selection';
+import type { Node as PmNode, ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, ReadonlyTransaction, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import type { ContentNodeWithPos, NodeWithPos } from '@atlaskit/editor-prosemirror/utils';
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+export declare const getDecorations: (tr: Transaction | ReadonlyTransaction) => DecorationSet;
+/**
+ * Use `getNodesToDecorateFromSelection` to collect and return
+ * a list of nodes within the Selection that should have Selection
+ * decorations applied. This allows selection styles to be added to
+ * nested nodes. It will ignore text nodes as decorations are
+ * applied natively and also ignore nodes that don't completely
+ * sit within the given `Selection`.
+ */
+export declare const getNodesToDecorateFromSelection: (selection: Selection, doc: PmNode) => {
+    node: PmNode;
+    pos: number;
+}[];
+export declare function shouldRecalcDecorations({ oldEditorState, newEditorState, }: {
+    oldEditorState: EditorState;
+    newEditorState: EditorState;
+}): boolean;
+export declare const isSelectableContainerNode: (node?: PmNode | null) => boolean;
+export declare const isSelectableChildNode: (node?: PmNode | null) => boolean;
+/**
+ * Finds closest parent node that is a selectable block container node
+ * If it finds a parent that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+export declare const findSelectableContainerParent: (selection: Selection) => ContentNodeWithPos | undefined;
+/**
+ * Finds node before that is a selectable block container node, starting
+ * from $pos.depth + 1 and working in
+ * If it finds a node that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+export declare const findSelectableContainerBefore: ($pos: ResolvedPos, doc: PmNode) => NodeWithPos | undefined;
+/**
+ * Finds node after that is a selectable block container node, starting
+ * from $pos.depth + 1 and working in
+ * If it finds a node that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+export declare const findSelectableContainerAfter: ($pos: ResolvedPos, doc: PmNode) => NodeWithPos | undefined;
+/**
+ * Finds first child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+export declare const findFirstChildNodeToSelect: (parent: PmNode) => NodeWithPos | undefined;
+/**
+ * Finds last child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+export declare const findLastChildNodeToSelect: (parent: PmNode) => NodeWithPos | undefined;
+export declare const isSelectionAtStartOfParentNode: ($pos: ResolvedPos, selection: Selection) => boolean;
+export declare const isSelectionAtEndOfParentNode: ($pos: ResolvedPos, selection: Selection) => boolean;
+export { getNodeSelectionAnalyticsPayload, getAllSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, createSelectionClickHandler, };

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@atlaskit/editor-plugin-selection",
+  "version": "0.1.0",
+  "description": "Selection plugin for @atlaskit/editor-core",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": "https://bitbucket.org/atlassian/atlassian-frontend",
+  "author": "Atlassian Pty Ltd",
+  "license": "Apache-2.0",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "module:es2019": "dist/es2019/index.js",
+  "types": "dist/types/index.d.ts",
+  "sideEffects": false,
+  "atlaskit:src": "src/index.ts",
+  "atlassian": {
+    "team": "Editor: Lego",
+    "releaseModel": "continuous",
+    "singleton": true
+  },
+  "dependencies": {
+    "@atlaskit/editor-common": "^76.8.0",
+    "@atlaskit/editor-prosemirror": "1.1.0",
+    "@atlaskit/editor-shared-styles": "^2.7.0",
+    "@atlaskit/editor-tables": "^2.3.10",
+    "@babel/runtime": "^7.0.0"
+  },
+  "peerDependencies": {
+    "react": "^16.8.0"
+  },
+  "devDependencies": {
+    "@af/editor-libra": "*",
+    "@af/visual-regression": "*",
+    "@atlaskit/editor-plugin-analytics": "^0.2.4",
+    "@atlaskit/editor-plugin-feature-flags": "^1.0.0",
+    "@atlaskit/editor-plugin-focus": "^0.2.1",
+    "@atlaskit/editor-plugin-grid": "^0.3.0",
+    "@atlaskit/editor-plugin-guideline": "^0.5.1",
+    "@atlaskit/editor-plugin-rule": "^0.1.2",
+    "@atlaskit/editor-plugin-width": "^0.2.2",
+    "@atlaskit/media-integration-test-helpers": "^3.0.0",
+    "@atlaskit/media-test-helpers": "^33.0.0",
+    "@atlaskit/ssr": "*",
+    "@atlaskit/visual-regression": "*",
+    "@atlaskit/webdriver-runner": "*",
+    "@atlassian/atlassian-frontend-prettier-config-1.0.0": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.0",
+    "@testing-library/react": "^12.1.5",
+    "react-dom": "^16.8.0",
+    "typescript": "~4.9.5",
+    "wait-for-expect": "^1.2.0"
+  },
+  "techstack": {
+    "@atlassian/frontend": {
+      "import-structure": [
+        "atlassian-conventions"
+      ],
+      "circular-dependencies": [
+        "file-and-folder-level"
+      ]
+    },
+    "@repo/internal": {
+      "dom-events": "use-bind-event-listener",
+      "analytics": [
+        "analytics-next"
+      ],
+      "design-tokens": [
+        "color"
+      ],
+      "theming": [
+        "react-context"
+      ],
+      "ui-components": [
+        "lite-mode"
+      ],
+      "deprecation": [
+        "no-deprecated-imports"
+      ],
+      "styling": [
+        "static",
+        "emotion"
+      ],
+      "imports": [
+        "import-no-extraneous-disable-for-examples-and-docs"
+      ]
+    }
+  },
+  "af:exports": {
+    ".": "./src/index.ts",
+    "./types": "./src/types.ts"
+  },
+  "prettier": "@atlassian/atlassian-frontend-prettier-config-1.0.0"
+}

package/types/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@atlaskit/editor-plugin-selection/types",
+  "main": "../dist/cjs/types.js",
+  "module": "../dist/esm/types.js",
+  "module:es2019": "../dist/es2019/types.js",
+  "sideEffects": false,
+  "types": "../dist/types/types.d.ts",
+  "typesVersions": {
+    ">=4.5 <4.9": {
+      "*": [
+        "../dist/types-ts4.5/types.d.ts"
+      ]
+    }
+  }
+}