@atlaskit/editor-plugin-annotation 25.0.1 → 25.0.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/editor-plugin-annotation
 
+## 25.0.3
+
+### Patch Changes
+
+- [`f6f0e4453badb`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/f6f0e4453badb) -
+  Add `resolveAnnotatableTargetFromLocalId`, which resolves a `localId` to the node an annotation
+  can be applied to — the node itself when it accepts the annotation mark or is a supported block
+  node, otherwise its closest accepting ancestor. Internal helper, not yet used by any code path.
+- Updated dependencies
+
+## 25.0.2
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 25.0.1
 
 ### Patch Changes

package/dist/cjs/pm-plugins/resolve-annotatable-target.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveAnnotatableTargetFromLocalId = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+var _utils2 = require("./utils");
+/**
+ * Resolves the node to annotate for a `localId`: the node itself when it accepts an annotation
+ * (allows the mark, or is a supported block node), otherwise its closest accepting ancestor.
+ * Returns undefined when nothing in the ancestor chain accepts one.
+ *
+ * Kept in sync with the renderer implementation so both sides resolve the same node.
+ */
+var resolveAnnotatableTargetFromLocalId = exports.resolveAnnotatableTargetFromLocalId = function resolveAnnotatableTargetFromLocalId(state, localId, opts) {
+  var supportedBlockNodes = opts.supportedBlockNodes;
+  var matches = (0, _utils.findNodePosByLocalIds)(state, [localId]);
+  if (matches.length === 0) {
+    return undefined;
+  }
+  var annotationMarkType = state.schema.marks.annotation;
+  var nodeAcceptsAnnotation = function nodeAcceptsAnnotation(node) {
+    return node.type.allowsMarkType(annotationMarkType) || (0, _utils2.isSupportedBlockNode)(node, supportedBlockNodes);
+  };
+  var _matches$ = matches[0],
+    node = _matches$.node,
+    pos = _matches$.pos;
+  if (nodeAcceptsAnnotation(node)) {
+    return {
+      node: node,
+      pos: pos
+    };
+  }
+
+  // Ancestors only — never descendants.
+  var $pos = state.doc.resolve(pos);
+  for (var depth = $pos.depth; depth >= 0; depth--) {
+    var ancestor = $pos.node(depth);
+    if (nodeAcceptsAnnotation(ancestor)) {
+      return {
+        node: ancestor,
+        pos: depth === 0 ? 0 : $pos.before(depth)
+      };
+    }
+  }
+  return undefined;
+};

package/dist/es2019/pm-plugins/resolve-annotatable-target.js

@@ -0,0 +1,44 @@
+import { findNodePosByLocalIds } from '@atlaskit/editor-common/utils';
+import { isSupportedBlockNode } from './utils';
+
+/**
+ * Resolves the node to annotate for a `localId`: the node itself when it accepts an annotation
+ * (allows the mark, or is a supported block node), otherwise its closest accepting ancestor.
+ * Returns undefined when nothing in the ancestor chain accepts one.
+ *
+ * Kept in sync with the renderer implementation so both sides resolve the same node.
+ */
+export const resolveAnnotatableTargetFromLocalId = (state, localId, opts) => {
+  const {
+    supportedBlockNodes
+  } = opts;
+  const matches = findNodePosByLocalIds(state, [localId]);
+  if (matches.length === 0) {
+    return undefined;
+  }
+  const annotationMarkType = state.schema.marks.annotation;
+  const nodeAcceptsAnnotation = node => node.type.allowsMarkType(annotationMarkType) || isSupportedBlockNode(node, supportedBlockNodes);
+  const {
+    node,
+    pos
+  } = matches[0];
+  if (nodeAcceptsAnnotation(node)) {
+    return {
+      node,
+      pos
+    };
+  }
+
+  // Ancestors only — never descendants.
+  const $pos = state.doc.resolve(pos);
+  for (let depth = $pos.depth; depth >= 0; depth--) {
+    const ancestor = $pos.node(depth);
+    if (nodeAcceptsAnnotation(ancestor)) {
+      return {
+        node: ancestor,
+        pos: depth === 0 ? 0 : $pos.before(depth)
+      };
+    }
+  }
+  return undefined;
+};

package/dist/esm/pm-plugins/resolve-annotatable-target.js

@@ -0,0 +1,43 @@
+import { findNodePosByLocalIds } from '@atlaskit/editor-common/utils';
+import { isSupportedBlockNode } from './utils';
+
+/**
+ * Resolves the node to annotate for a `localId`: the node itself when it accepts an annotation
+ * (allows the mark, or is a supported block node), otherwise its closest accepting ancestor.
+ * Returns undefined when nothing in the ancestor chain accepts one.
+ *
+ * Kept in sync with the renderer implementation so both sides resolve the same node.
+ */
+export var resolveAnnotatableTargetFromLocalId = function resolveAnnotatableTargetFromLocalId(state, localId, opts) {
+  var supportedBlockNodes = opts.supportedBlockNodes;
+  var matches = findNodePosByLocalIds(state, [localId]);
+  if (matches.length === 0) {
+    return undefined;
+  }
+  var annotationMarkType = state.schema.marks.annotation;
+  var nodeAcceptsAnnotation = function nodeAcceptsAnnotation(node) {
+    return node.type.allowsMarkType(annotationMarkType) || isSupportedBlockNode(node, supportedBlockNodes);
+  };
+  var _matches$ = matches[0],
+    node = _matches$.node,
+    pos = _matches$.pos;
+  if (nodeAcceptsAnnotation(node)) {
+    return {
+      node: node,
+      pos: pos
+    };
+  }
+
+  // Ancestors only — never descendants.
+  var $pos = state.doc.resolve(pos);
+  for (var depth = $pos.depth; depth >= 0; depth--) {
+    var ancestor = $pos.node(depth);
+    if (nodeAcceptsAnnotation(ancestor)) {
+      return {
+        node: ancestor,
+        pos: depth === 0 ? 0 : $pos.before(depth)
+      };
+    }
+  }
+  return undefined;
+};

package/dist/types/pm-plugins/resolve-annotatable-target.d.ts

@@ -0,0 +1,15 @@
+import type { Node } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Resolves the node to annotate for a `localId`: the node itself when it accepts an annotation
+ * (allows the mark, or is a supported block node), otherwise its closest accepting ancestor.
+ * Returns undefined when nothing in the ancestor chain accepts one.
+ *
+ * Kept in sync with the renderer implementation so both sides resolve the same node.
+ */
+export declare const resolveAnnotatableTargetFromLocalId: (state: EditorState, localId: string, opts: {
+    supportedBlockNodes?: string[];
+}) => {
+    node: Node;
+    pos: number;
+} | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-annotation",
-	"version": "25.0.1",
+	"version": "25.0.3",
 	"description": "Annotation plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -31,7 +31,7 @@
 		"@atlaskit/editor-toolbar-model": "^1.2.0",
 		"@atlaskit/icon": "^38.0.0",
 		"@atlaskit/platform-feature-flags": "^2.2.0",
-		"@atlaskit/tmp-editor-statsig": "^225.0.0",
+		"@atlaskit/tmp-editor-statsig": "^227.0.0",
 		"@babel/runtime": "^7.0.0"
 	},
 	"peerDependencies": {