feat: add isNestedElementField() and isRepeaterField()

src/index.ts

@@ -12,14 +12,20 @@ export type { Options } from "./plugin/fieldViews/DropdownFieldView";
 export type { FieldView } from "./plugin/fieldViews/FieldView";
 export { createTextField } from "./plugin/fieldViews/TextFieldView";
 export { createRichTextField } from "./plugin/fieldViews/RichTextFieldView";
-export { createNestedElementField } from "./plugin/fieldViews/NestedElementFieldView";
+export {
+  createNestedElementField,
+  isNestedElementField,
+} from "./plugin/fieldViews/NestedElementFieldView";
 export { createCheckBoxField } from "./plugin/fieldViews/CheckboxFieldView";
 export {
   createCustomDropdownField,
   createCustomField,
 } from "./plugin/fieldViews/CustomFieldView";
 export { createFlatRichTextField } from "./plugin/fieldViews/RichTextFieldView";
-export { createRepeaterField } from "./plugin/fieldViews/RepeaterFieldView";
+export {
+  createRepeaterField,
+  isRepeaterField,
+} from "./plugin/fieldViews/RepeaterFieldView";
 
 export {
   htmlMaxLength,

src/plugin/fieldViews/NestedElementFieldView.ts

@@ -42,13 +42,20 @@ export interface NestedElementFieldDescription
 export const anyDescendantFieldIsNestedElementField = (node: Node) => {
   let descendantFieldIsNestedElementField = false;
   node.descendants((node) => {
-    if (node.type.spec.group?.includes("nested-element-field")) {
+    if (node.type.spec.group?.includes(nestedElementFieldGroupName)) {
       descendantFieldIsNestedElementField = true;
     }
   });
   return descendantFieldIsNestedElementField;
 };
 
+export const nestedElementFieldGroupName = "nested-element-field";
+
+export const isNestedElementAttribute = "isNestedElement";
+
+export const isNestedElementField = (node: Node) =>
+  node.attrs[isNestedElementAttribute] === true;
+
 export const createNestedElementField = ({
   absentOnEmpty,
   attrs,

src/plugin/fieldViews/RepeaterFieldView.ts

@@ -15,6 +15,13 @@ export const getRepeaterParentNodeName = (nodeName: string) =>
 export const getRepeaterChildNameFromParent = (nodeName: string) =>
   nodeName.replace("__parent", "__child");
 
+export const isRepeaterParentAttribute = "isRepeaterParent";
+export const isRepeaterChildAttribute = "isRepeaterParent";
+
+export const isRepeaterField = (node: Node): boolean =>
+  node.attrs[isRepeaterParentAttribute] === true ||
+  node.attrs[isRepeaterChildAttribute] === true;
+
 export const createRepeaterField = <FDesc extends FieldDescriptions<string>>(
   fields: FDesc,
   minChildren = 0

src/plugin/fieldViews/__tests__/NestedElementFieldView.spec.ts

@@ -0,0 +1,35 @@
+import {
+  createEditorWithElements,
+  createNoopElement,
+} from "../../helpers/test";
+import { isNestedElementField } from "../NestedElementFieldView";
+
+const nestedTestElement = createNoopElement({
+  nestedField: {
+    type: "nestedElement",
+    content: "block+",
+  },
+});
+
+describe("isNestedElementField", () => {
+  it("should correctly identify a nested element field", () => {
+    const { view, insertElement } = createEditorWithElements({
+      nestedTestElement,
+    });
+
+    insertElement({
+      elementName: "nestedTestElement",
+      values: {
+        nestedField: [],
+      },
+    })(view.state, view.dispatch);
+
+    const docNode = view.state.doc;
+    const nestedFieldNode = view.state.doc.firstChild?.firstChild;
+
+    expect(isNestedElementField(docNode)).toBe(false);
+    expect(!!nestedFieldNode && isNestedElementField(nestedFieldNode)).toBe(
+      true
+    );
+  });
+});

src/plugin/fieldViews/__tests__/RepeaterFieldView.spec.ts

@@ -3,7 +3,24 @@ import {
   createEditorWithElements,
   createNoopElement,
 } from "../../helpers/test";
-import { RepeaterFieldView } from "../RepeaterFieldView";
+import { isRepeaterField, RepeaterFieldView } from "../RepeaterFieldView";
+
+const nestedTestElement = createNoopElement({
+  nestedField: {
+    type: "nestedElement",
+    content: "block+",
+  },
+});
+
+const testElement = createNoopElement({
+  repeater1: {
+    type: "repeater",
+    fields: {
+      field1: { type: "richText" },
+    },
+    minChildren: 0,
+  },
+});
 
 describe("RepeaterFieldView", () => {
   it("should add a repeater child at the start when index is -1", () => {
@@ -172,27 +189,33 @@ describe("RepeaterFieldView", () => {
   });
 });
 
+describe("isRepeaterFieldNode", () => {
+  it("should correctly identify a repeater field node", () => {
+    const { view, insertElement } = createEditorWithElements({
+      testElement,
+    });
+
+    insertElement({
+      elementName: "testElement",
+      values: {
+        repeater1: [],
+      },
+    })(view.state, view.dispatch);
+
+    const docNode = view.state.doc;
+    const repeaterNode = view.state.doc.firstChild?.firstChild;
+
+    expect(isRepeaterField(docNode)).toBe(false);
+    expect(!!repeaterNode && isRepeaterField(repeaterNode)).toBe(true);
+  });
+});
+
 const testRepeaterMutation = (
   initialContent: string[],
   mutation: (repeaterFieldView: RepeaterFieldView) => void,
   expectedFinalContent: string[],
   minChildren = 0
 ) => {
-  const nestedTestElement = createNoopElement({
-    nestedField: {
-      type: "nestedElement",
-      content: "block+",
-    },
-  });
-  const testElement = createNoopElement({
-    repeater1: {
-      type: "repeater",
-      fields: {
-        field1: { type: "richText" },
-      },
-      minChildren: 0,
-    },
-  });
   const { view, insertElement } = createEditorWithElements({
     nestedTestElement,
     testElement,

src/plugin/nodeSpec.ts

@@ -3,10 +3,16 @@ import type { Node, NodeSpec, NodeType, Schema } from "prosemirror-model";
 import { DOMParser } from "prosemirror-model";
 import { useTyperighterAttrs } from "../elements/helpers/typerighter";
 import { FieldContentType } from "./fieldViews/FieldView";
+import {
+  isNestedElementAttribute,
+  nestedElementFieldGroupName,
+} from "./fieldViews/NestedElementFieldView";
 import type { RepeaterFieldDescription } from "./fieldViews/RepeaterFieldView";
 import {
   getRepeaterChildNodeName,
   getRepeaterParentNodeName,
+  isRepeaterChildAttribute,
+  isRepeaterParentAttribute,
   repeaterFieldType,
 } from "./fieldViews/RepeaterFieldView";
 import { RepeaterFieldMapIDKey } from "./helpers/constants";
@@ -124,7 +130,7 @@ export const getNodeSpecForField = (
     case "nestedElement": {
       return {
         [nodeName]: {
-          group: `${fieldGroupName} nested-element-field`,
+          group: `${fieldGroupName} ${nestedElementFieldGroupName}`,
           content: field.content ?? "element+",
           toDOM: getDefaultToDOMForContentNode(nodeName),
           parseDOM: [
@@ -135,7 +141,12 @@ export const getNodeSpecForField = (
             },
           ],
           marks: field.marks,
-          attrs: field.attrs,
+          attrs: {
+            [isNestedElementAttribute]: {
+              default: true,
+            },
+            ...field.attrs,
+          },
         },
       };
     }
@@ -217,7 +228,12 @@ export const getNodeSpecForField = (
           content: `${childNodeName}{${field.minChildren},}`,
           toDOM: getDefaultToDOMForRepeaterNode(parentNodeName),
           parseDOM: getDefaultParseDOMForLeafNode(parentNodeName),
-          attrs: { ...useTyperighterAttrs },
+          attrs: {
+            [isRepeaterParentAttribute]: {
+              default: true,
+            },
+            ...useTyperighterAttrs,
+          },
         },
         [childNodeName]: {
           group: fieldGroupName,
@@ -228,6 +244,9 @@ export const getNodeSpecForField = (
             [RepeaterFieldMapIDKey]: {
               default: getRepeaterID(),
             },
+            [isRepeaterChildAttribute]: {
+              default: true,
+            },
             ...useTyperighterAttrs,
           },
         },