fixup! feat: Portable Text-native node traversal

Author: christianhg

packages/editor/src/node-traversal/get-children.test.ts

@@ -1,12 +1,14 @@
 import {describe, expect, test} from 'vitest'
 import {getChildren} from './get-children'
-import {createTestbed} from './testbed'
+import {allEditableTypes, createTestbed} from './testbed'
 
 describe(getChildren.name, () => {
   const testbed = createTestbed()
 
   test('root children', () => {
-    expect(getChildren(testbed.root, [], testbed.schema)).toEqual([
+    expect(
+      getChildren(testbed.root, [], testbed.schema, allEditableTypes),
+    ).toEqual([
       testbed.textBlock1,
       testbed.image,
       testbed.textBlock2,
@@ -16,63 +18,74 @@ describe(getChildren.name, () => {
   })
 
   test('text block children', () => {
-    expect(getChildren(testbed.root, [0], testbed.schema)).toEqual([
-      testbed.span1,
-      testbed.stockTicker1,
-      testbed.span2,
-    ])
+    expect(
+      getChildren(testbed.root, [0], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.span1, testbed.stockTicker1, testbed.span2])
   })
 
   test('code block children (code lines)', () => {
-    expect(getChildren(testbed.root, [3], testbed.schema)).toEqual([
-      testbed.codeLine1,
-      testbed.codeLine2,
-    ])
+    expect(
+      getChildren(testbed.root, [3], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.codeLine1, testbed.codeLine2])
   })
 
   test('code line children', () => {
-    expect(getChildren(testbed.root, [3, 0], testbed.schema)).toEqual([
-      testbed.codeSpan1,
-    ])
+    expect(
+      getChildren(testbed.root, [3, 0], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.codeSpan1])
   })
 
   test('table children (rows)', () => {
-    expect(getChildren(testbed.root, [4], testbed.schema)).toEqual([
-      testbed.row1,
-      testbed.row2,
-    ])
+    expect(
+      getChildren(testbed.root, [4], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.row1, testbed.row2])
   })
 
   test('row children (cells)', () => {
-    expect(getChildren(testbed.root, [4, 0], testbed.schema)).toEqual([
-      testbed.cell1,
-      testbed.cell2,
-    ])
+    expect(
+      getChildren(testbed.root, [4, 0], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.cell1, testbed.cell2])
   })
 
   test('cell with multiple blocks', () => {
-    expect(getChildren(testbed.root, [4, 0, 0], testbed.schema)).toEqual([
-      testbed.cellBlock1,
-      testbed.cellBlock2,
-    ])
+    expect(
+      getChildren(testbed.root, [4, 0, 0], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.cellBlock1, testbed.cellBlock2])
   })
 
   test('block inside cell children', () => {
-    expect(getChildren(testbed.root, [4, 0, 0, 0], testbed.schema)).toEqual([
-      testbed.cellSpan1,
-      testbed.stockTicker2,
-    ])
+    expect(
+      getChildren(testbed.root, [4, 0, 0, 0], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.cellSpan1, testbed.stockTicker2])
   })
 
   test('leaf node returns empty array', () => {
-    expect(getChildren(testbed.root, [0, 0], testbed.schema)).toEqual([])
+    expect(
+      getChildren(testbed.root, [0, 0], testbed.schema, allEditableTypes),
+    ).toEqual([])
   })
 
   test('block object without children returns empty array', () => {
-    expect(getChildren(testbed.root, [1], testbed.schema)).toEqual([])
+    expect(
+      getChildren(testbed.root, [1], testbed.schema, allEditableTypes),
+    ).toEqual([])
   })
 
   test('invalid path returns empty array', () => {
-    expect(getChildren(testbed.root, [99], testbed.schema)).toEqual([])
+    expect(
+      getChildren(testbed.root, [99], testbed.schema, allEditableTypes),
+    ).toEqual([])
+  })
+
+  test('non-editable code block returns empty array', () => {
+    const tableOnly = new Set(['table', 'table.row', 'table.row.cell'])
+    expect(getChildren(testbed.root, [3], testbed.schema, tableOnly)).toEqual(
+      [],
+    )
+  })
+
+  test('non-editable table returns empty array', () => {
+    const codeOnly = new Set(['code-block'])
+    expect(getChildren(testbed.root, [4], testbed.schema, codeOnly)).toEqual([])
   })
 })

packages/editor/src/node-traversal/get-children.ts

@@ -9,9 +9,11 @@ export function getChildren(
   root: {children: Array<Node>},
   path: Array<number>,
   schema: EditorSchema,
+  editableTypes: Set<string>,
 ): Array<Node> {
   let currentChildren: Array<Node> = root.children
   let currentScope: ReadonlyArray<OfDefinition> | undefined
+  let scopePath = ''
 
   for (const index of path) {
     const node = currentChildren[index]
@@ -24,6 +26,12 @@ export function getChildren(
       currentChildren = node.children
       currentScope = undefined
     } else if (isObjectNode({schema}, node)) {
+      const scopedKey = scopePath ? `${scopePath}.${node._type}` : node._type
+
+      if (!editableTypes.has(scopedKey)) {
+        return []
+      }
+
       const arrayField = resolveChildArrayField(
         {schema, scope: currentScope},
         node,
@@ -37,6 +45,7 @@ export function getChildren(
         arrayField.name
       ] as Array<Node>
       currentScope = arrayField.of
+      scopePath = scopedKey
     } else {
       return []
     }

packages/editor/src/node-traversal/get-first.test.ts

@@ -1,47 +1,56 @@
 import {describe, expect, test} from 'vitest'
 import {getFirst} from './get-first'
-import {createTestbed} from './testbed'
+import {allEditableTypes, createTestbed} from './testbed'
 
 describe(getFirst.name, () => {
   const testbed = createTestbed()
 
   test('first descendant from root', () => {
-    expect(getFirst(testbed.root, [], testbed.schema)).toEqual([
-      testbed.textBlock1,
-      [0],
-    ])
+    expect(
+      getFirst(testbed.root, [], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.textBlock1, [0]])
   })
 
   test('first descendant of text block', () => {
-    expect(getFirst(testbed.root, [0], testbed.schema)).toEqual([
-      testbed.span1,
-      [0, 0],
-    ])
+    expect(
+      getFirst(testbed.root, [0], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.span1, [0, 0]])
   })
 
   test('first descendant of code block', () => {
-    expect(getFirst(testbed.root, [3], testbed.schema)).toEqual([
-      testbed.codeLine1,
-      [3, 0],
-    ])
+    expect(
+      getFirst(testbed.root, [3], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.codeLine1, [3, 0]])
   })
 
   test('first descendant of table', () => {
-    expect(getFirst(testbed.root, [4], testbed.schema)).toEqual([
-      testbed.row1,
-      [4, 0],
-    ])
+    expect(
+      getFirst(testbed.root, [4], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.row1, [4, 0]])
   })
 
   test('leaf node returns undefined', () => {
-    expect(getFirst(testbed.root, [0, 0], testbed.schema)).toBeUndefined()
+    expect(
+      getFirst(testbed.root, [0, 0], testbed.schema, allEditableTypes),
+    ).toBeUndefined()
   })
 
   test('void block object returns undefined', () => {
-    expect(getFirst(testbed.root, [1], testbed.schema)).toBeUndefined()
+    expect(
+      getFirst(testbed.root, [1], testbed.schema, allEditableTypes),
+    ).toBeUndefined()
   })
 
   test('invalid path returns undefined', () => {
-    expect(getFirst(testbed.root, [99], testbed.schema)).toBeUndefined()
+    expect(
+      getFirst(testbed.root, [99], testbed.schema, allEditableTypes),
+    ).toBeUndefined()
+  })
+
+  test('first of non-editable container returns undefined', () => {
+    const tableOnly = new Set(['table', 'table.row', 'table.row.cell'])
+    expect(
+      getFirst(testbed.root, [3], testbed.schema, tableOnly),
+    ).toBeUndefined()
   })
 })

packages/editor/src/node-traversal/get-first.ts

@@ -6,8 +6,9 @@ export function getFirst(
   root: {children: Array<Node>},
   path: Array<number>,
   schema: EditorSchema,
+  editableTypes: Set<string>,
 ): [Node, Array<number>] | undefined {
-  const children = getChildren(root, path, schema)
+  const children = getChildren(root, path, schema, editableTypes)
   const first = children[0]
 
   if (!first) {

packages/editor/src/node-traversal/get-last.test.ts

@@ -1,47 +1,56 @@
 import {describe, expect, test} from 'vitest'
 import {getLast} from './get-last'
-import {createTestbed} from './testbed'
+import {allEditableTypes, createTestbed} from './testbed'
 
 describe(getLast.name, () => {
   const testbed = createTestbed()
 
   test('last descendant from root', () => {
-    expect(getLast(testbed.root, [], testbed.schema)).toEqual([
-      testbed.table,
-      [4],
-    ])
+    expect(getLast(testbed.root, [], testbed.schema, allEditableTypes)).toEqual(
+      [testbed.table, [4]],
+    )
   })
 
   test('last descendant of text block', () => {
-    expect(getLast(testbed.root, [0], testbed.schema)).toEqual([
-      testbed.span2,
-      [0, 2],
-    ])
+    expect(
+      getLast(testbed.root, [0], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.span2, [0, 2]])
   })
 
   test('last descendant of code block', () => {
-    expect(getLast(testbed.root, [3], testbed.schema)).toEqual([
-      testbed.codeLine2,
-      [3, 1],
-    ])
+    expect(
+      getLast(testbed.root, [3], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.codeLine2, [3, 1]])
   })
 
   test('last descendant of table', () => {
-    expect(getLast(testbed.root, [4], testbed.schema)).toEqual([
-      testbed.row2,
-      [4, 1],
-    ])
+    expect(
+      getLast(testbed.root, [4], testbed.schema, allEditableTypes),
+    ).toEqual([testbed.row2, [4, 1]])
   })
 
   test('leaf node returns undefined', () => {
-    expect(getLast(testbed.root, [0, 0], testbed.schema)).toBeUndefined()
+    expect(
+      getLast(testbed.root, [0, 0], testbed.schema, allEditableTypes),
+    ).toBeUndefined()
   })
 
   test('void block object returns undefined', () => {
-    expect(getLast(testbed.root, [1], testbed.schema)).toBeUndefined()
+    expect(
+      getLast(testbed.root, [1], testbed.schema, allEditableTypes),
+    ).toBeUndefined()
   })
 
   test('invalid path returns undefined', () => {
-    expect(getLast(testbed.root, [99], testbed.schema)).toBeUndefined()
+    expect(
+      getLast(testbed.root, [99], testbed.schema, allEditableTypes),
+    ).toBeUndefined()
+  })
+
+  test('last of non-editable container returns undefined', () => {
+    const tableOnly = new Set(['table', 'table.row', 'table.row.cell'])
+    expect(
+      getLast(testbed.root, [3], testbed.schema, tableOnly),
+    ).toBeUndefined()
   })
 })

packages/editor/src/node-traversal/get-last.ts

@@ -6,8 +6,9 @@ export function getLast(
   root: {children: Array<Node>},
   path: Array<number>,
   schema: EditorSchema,
+  editableTypes: Set<string>,
 ): [Node, Array<number>] | undefined {
-  const children = getChildren(root, path, schema)
+  const children = getChildren(root, path, schema, editableTypes)
   const lastIndex = children.length - 1
   const last = children[lastIndex]