@portabletext/editor 1.55.0 → 1.55.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.55.0",
+  "version": "1.55.2",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -86,7 +86,7 @@
   "devDependencies": {
     "@portabletext/toolkit": "^2.0.17",
     "@sanity/diff-match-patch": "^3.2.0",
-    "@sanity/pkg-utils": "^7.8.4",
+    "@sanity/pkg-utils": "^7.8.5",
     "@sanity/schema": "^3.93.0",
     "@sanity/types": "^3.93.0",
     "@testing-library/react": "^16.3.0",
@@ -98,8 +98,8 @@
     "@typescript-eslint/eslint-plugin": "^8.34.0",
     "@typescript-eslint/parser": "^8.34.0",
     "@vitejs/plugin-react": "^4.5.2",
-    "@vitest/browser": "^3.2.3",
-    "@vitest/coverage-istanbul": "^3.2.3",
+    "@vitest/browser": "^3.2.4",
+    "@vitest/coverage-istanbul": "^3.2.4",
     "babel-plugin-react-compiler": "19.1.0-rc.2",
     "eslint": "8.57.1",
     "eslint-plugin-react-hooks": "0.0.0-experimental-12bc60f5-20250613",
@@ -109,9 +109,9 @@
     "rxjs": "^7.8.2",
     "typescript": "5.8.3",
     "vite": "^6.2.5",
-    "vitest": "^3.2.3",
+    "vitest": "^3.2.4",
     "vitest-browser-react": "^0.3.0",
-    "racejar": "1.2.7"
+    "racejar": "1.2.8"
   },
   "peerDependencies": {
     "@sanity/schema": "^3.93.0",

package/src/editor/create-slate-editor.tsx

@@ -46,15 +46,20 @@ export function createSlateEditor(config: SlateEditorConfig): SlateEditor {
     config.editorActor.getSnapshot().context,
   )
   instance.value = [placeholderBlock]
+  instance.blockIndexMap = new Map<string, number>()
+  instance.listIndexMap = new Map<string, number>()
 
-  const {blockIndexMap, listIndexMap} = buildIndexMaps(
-    config.editorActor.getSnapshot().context,
-    instance.value,
+  buildIndexMaps(
+    {
+      schema: config.editorActor.getSnapshot().context.schema,
+      value: instance.value,
+    },
+    {
+      blockIndexMap: instance.blockIndexMap,
+      listIndexMap: instance.listIndexMap,
+    },
   )
 
-  instance.blockIndexMap = blockIndexMap
-  instance.listIndexMap = listIndexMap
-
   const initialValue = toSlateValue(instance.value, {
     schemaTypes: config.editorActor.getSnapshot().context.schema,
   })

package/src/editor/plugins/slate-plugin.update-value.ts

@@ -21,9 +21,16 @@ export function pluginUpdateValue(
       operation,
     )
 
-    const {blockIndexMap, listIndexMap} = buildIndexMaps(context, editor.value)
-    editor.blockIndexMap = blockIndexMap
-    editor.listIndexMap = listIndexMap
+    buildIndexMaps(
+      {
+        schema: context.schema,
+        value: editor.value,
+      },
+      {
+        blockIndexMap: editor.blockIndexMap,
+        listIndexMap: editor.listIndexMap,
+      },
+    )
 
     apply(operation)
   }

package/src/internal-utils/build-index-maps.test.ts

@@ -44,168 +44,210 @@ const schema = compileSchemaDefinition(
 )
 
 describe(buildIndexMaps.name, () => {
+  const blockIndexMap = new Map<string, number>()
+  const listIndexMap = new Map<string, number>()
+
   test('empty', () => {
-    expect(buildIndexMaps({schema}, [])).toEqual({
-      blockIndexMap: new Map(),
-      listIndexMap: new Map(),
-    })
+    buildIndexMaps({schema, value: []}, {blockIndexMap, listIndexMap})
+    expect(blockIndexMap).toEqual(new Map())
+    expect(listIndexMap).toEqual(new Map())
   })
 
   test('single list item', () => {
-    expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 1}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([['k0', 0]]),
-      listIndexMap: new Map([['k0', 1]]),
-    })
+    buildIndexMaps(
+      {schema, value: [textBlock('k0', {listItem: 'number', level: 1})]},
+      {blockIndexMap, listIndexMap},
+    )
+    expect(blockIndexMap).toEqual(new Map([['k0', 0]]))
+    expect(listIndexMap).toEqual(new Map([['k0', 1]]))
   })
 
   test('single indented list item', () => {
-    expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 2}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([['k0', 0]]),
-      listIndexMap: new Map([['k0', 1]]),
-    })
+    buildIndexMaps(
+      {schema, value: [textBlock('k0', {listItem: 'number', level: 2})]},
+      {blockIndexMap, listIndexMap},
+    )
+    expect(blockIndexMap).toEqual(new Map([['k0', 0]]))
+    expect(listIndexMap).toEqual(new Map([['k0', 1]]))
   })
 
   test('two lists broken up by a paragraph', () => {
-    expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 1}),
-        textBlock('k1', {listItem: 'number', level: 1}),
-        textBlock('k2', {}),
-        textBlock('k3', {listItem: 'number', level: 1}),
-        textBlock('k4', {listItem: 'number', level: 1}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([
+    buildIndexMaps(
+      {
+        schema,
+        value: [
+          textBlock('k0', {listItem: 'number', level: 1}),
+          textBlock('k1', {listItem: 'number', level: 1}),
+          textBlock('k2', {}),
+          textBlock('k3', {listItem: 'number', level: 1}),
+          textBlock('k4', {listItem: 'number', level: 1}),
+        ],
+      },
+      {blockIndexMap, listIndexMap},
+    )
+    expect(blockIndexMap).toEqual(
+      new Map([
         ['k0', 0],
         ['k1', 1],
         ['k2', 2],
         ['k3', 3],
         ['k4', 4],
       ]),
-      listIndexMap: new Map([
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
         ['k0', 1],
         ['k1', 2],
         ['k3', 1],
         ['k4', 2],
       ]),
-    })
+    )
   })
 
   test('two lists broken up by an image', () => {
-    expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 1}),
-        textBlock('k1', {listItem: 'number', level: 1}),
-        blockObject('k2', 'image'),
-        textBlock('k3', {listItem: 'number', level: 1}),
-        textBlock('k4', {listItem: 'number', level: 1}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([
+    buildIndexMaps(
+      {
+        schema,
+        value: [
+          textBlock('k0', {listItem: 'number', level: 1}),
+          textBlock('k1', {listItem: 'number', level: 1}),
+          blockObject('k2', 'image'),
+          textBlock('k3', {listItem: 'number', level: 1}),
+          textBlock('k4', {listItem: 'number', level: 1}),
+        ],
+      },
+      {blockIndexMap, listIndexMap},
+    )
+    expect(blockIndexMap).toEqual(
+      new Map([
         ['k0', 0],
         ['k1', 1],
         ['k2', 2],
         ['k3', 3],
         ['k4', 4],
       ]),
-      listIndexMap: new Map([
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
         ['k0', 1],
         ['k1', 2],
         ['k3', 1],
         ['k4', 2],
       ]),
-    })
+    )
   })
 
   test('numbered lists broken up by a bulleted list', () => {
     expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 1}),
-        textBlock('k1', {listItem: 'bullet', level: 1}),
-        textBlock('k2', {listItem: 'number', level: 1}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([
+      buildIndexMaps(
+        {
+          schema,
+          value: [
+            textBlock('k0', {listItem: 'number', level: 1}),
+            textBlock('k1', {listItem: 'bullet', level: 1}),
+            textBlock('k2', {listItem: 'number', level: 1}),
+          ],
+        },
+        {blockIndexMap, listIndexMap},
+      ),
+    )
+    expect(blockIndexMap).toEqual(
+      new Map([
         ['k0', 0],
         ['k1', 1],
         ['k2', 2],
       ]),
-      listIndexMap: new Map([
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
         ['k0', 1],
         ['k1', 1],
         ['k2', 1],
       ]),
-    })
+    )
   })
 
   test('simple indented list', () => {
-    expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 1}),
-        textBlock('k1', {listItem: 'number', level: 2}),
-        textBlock('k2', {listItem: 'number', level: 2}),
-        textBlock('k3', {listItem: 'number', level: 1}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([
+    buildIndexMaps(
+      {
+        schema,
+        value: [
+          textBlock('k0', {listItem: 'number', level: 1}),
+          textBlock('k1', {listItem: 'number', level: 2}),
+          textBlock('k2', {listItem: 'number', level: 2}),
+          textBlock('k3', {listItem: 'number', level: 1}),
+        ],
+      },
+      {blockIndexMap, listIndexMap},
+    )
+    expect(blockIndexMap).toEqual(
+      new Map([
         ['k0', 0],
         ['k1', 1],
         ['k2', 2],
         ['k3', 3],
       ]),
-      listIndexMap: new Map([
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
         ['k0', 1],
         ['k1', 1],
         ['k2', 2],
         ['k3', 2],
       ]),
-    })
+    )
   })
 
   test('reverse indented list', () => {
     expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 2}),
-        textBlock('k1', {listItem: 'number', level: 1}),
-        textBlock('k2', {listItem: 'number', level: 2}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([
+      buildIndexMaps(
+        {
+          schema,
+          value: [
+            textBlock('k0', {listItem: 'number', level: 2}),
+            textBlock('k1', {listItem: 'number', level: 1}),
+            textBlock('k2', {listItem: 'number', level: 2}),
+          ],
+        },
+        {blockIndexMap, listIndexMap},
+      ),
+    )
+    expect(blockIndexMap).toEqual(
+      new Map([
         ['k0', 0],
         ['k1', 1],
         ['k2', 2],
       ]),
-      listIndexMap: new Map([
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
         ['k0', 1],
         ['k1', 1],
         ['k2', 1],
       ]),
-    })
+    )
   })
 
   test('complex list', () => {
-    expect(
-      buildIndexMaps({schema}, [
-        textBlock('k0', {listItem: 'number', level: 1}),
-        textBlock('k1', {listItem: 'number', level: 3}),
-        textBlock('k2', {listItem: 'number', level: 2}),
-        textBlock('k3', {listItem: 'number', level: 3}),
-        textBlock('k4', {listItem: 'number', level: 1}),
-        textBlock('k5', {listItem: 'number', level: 3}),
-        textBlock('k6', {listItem: 'number', level: 4}),
-        textBlock('k7', {listItem: 'number', level: 3}),
-        textBlock('k8', {listItem: 'number', level: 1}),
-      ]),
-    ).toEqual({
-      blockIndexMap: new Map([
+    buildIndexMaps(
+      {
+        schema,
+        value: [
+          textBlock('k0', {listItem: 'number', level: 1}),
+          textBlock('k1', {listItem: 'number', level: 3}),
+          textBlock('k2', {listItem: 'number', level: 2}),
+          textBlock('k3', {listItem: 'number', level: 3}),
+          textBlock('k4', {listItem: 'number', level: 1}),
+          textBlock('k5', {listItem: 'number', level: 3}),
+          textBlock('k6', {listItem: 'number', level: 4}),
+          textBlock('k7', {listItem: 'number', level: 3}),
+          textBlock('k8', {listItem: 'number', level: 1}),
+        ],
+      },
+      {blockIndexMap, listIndexMap},
+    )
+    expect(blockIndexMap).toEqual(
+      new Map([
         ['k0', 0],
         ['k1', 1],
         ['k2', 2],
@@ -216,7 +258,9 @@ describe(buildIndexMaps.name, () => {
         ['k7', 7],
         ['k8', 8],
       ]),
-      listIndexMap: new Map([
+    )
+    expect(listIndexMap).toEqual(
+      new Map([
         ['k0', 1],
         ['k1', 1],
         ['k2', 1],
@@ -227,6 +271,6 @@ describe(buildIndexMaps.name, () => {
         ['k7', 2],
         ['k8', 3],
       ]),
-    })
+    )
   })
 })

package/src/internal-utils/build-index-maps.ts

@@ -1,17 +1,25 @@
-import type {PortableTextBlock} from '@sanity/types'
 import type {EditorContext} from '../editor/editor-snapshot'
 import {isTextBlock} from './parse-blocks'
 
+const levelIndexMap = new Map<number, number>()
+
+/**
+ * Mutates the maps in place.
+ */
 export function buildIndexMaps(
-  context: Pick<EditorContext, 'schema'>,
-  value: Array<PortableTextBlock>,
-): {
-  blockIndexMap: Map<string, number>
-  listIndexMap: Map<string, number>
-} {
-  const blockIndexMap = new Map<string, number>()
-  const listIndexMap = new Map<string, number>()
-  const levelIndexMap = new Map<number, number>()
+  context: Pick<EditorContext, 'schema' | 'value'>,
+  {
+    blockIndexMap,
+    listIndexMap,
+  }: {
+    blockIndexMap: Map<string, number>
+    listIndexMap: Map<string, number>
+  },
+): void {
+  blockIndexMap.clear()
+  listIndexMap.clear()
+  levelIndexMap.clear()
+
   let previousListItem:
     | {
         listItem: string
@@ -19,8 +27,8 @@ export function buildIndexMaps(
       }
     | undefined
 
-  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
-    const block = value.at(blockIndex)
+  for (let blockIndex = 0; blockIndex < context.value.length; blockIndex++) {
+    const block = context.value.at(blockIndex)
 
     if (block === undefined) {
       continue
@@ -92,6 +100,4 @@ export function buildIndexMaps(
       listIndexMap.set(block._key, levelCounter + 1)
     }
   }
-
-  return {blockIndexMap, listIndexMap}
 }

package/src/internal-utils/paths.ts

@@ -1,39 +1,62 @@
-import {isKeySegment, type Path} from '@sanity/types'
-import {isEqual} from 'lodash'
-import {Editor, Element, type Descendant, type Path as SlatePath} from 'slate'
+import {Element, type Editor, type Path} from 'slate'
+import type {EditorSelectionPoint} from '..'
+import {
+  getBlockKeyFromSelectionPoint,
+  getChildKeyFromSelectionPoint,
+} from '../selection/selection-point'
 
-export function toSlatePath(path: Path, editor: Editor): SlatePath {
-  if (!editor) {
+export function toSlatePath(
+  path: EditorSelectionPoint['path'],
+  editor: Editor,
+): Path {
+  const blockKey = getBlockKeyFromSelectionPoint({
+    path,
+    offset: 0,
+  })
+
+  if (!blockKey) {
+    return []
+  }
+
+  const blockIndex = editor.blockIndexMap.get(blockKey)
+
+  if (blockIndex === undefined) {
     return []
   }
-  const [block, blockPath] = Array.from(
-    Editor.nodes(editor, {
-      at: [],
-      match: (n) =>
-        isKeySegment(path[0]) && (n as Descendant)._key === path[0]._key,
-    }),
-  )[0] || [undefined, undefined]
+
+  const block = editor.children.at(blockIndex)
 
   if (!block || !Element.isElement(block)) {
     return []
   }
 
   if (editor.isVoid(block)) {
-    return [blockPath[0], 0]
+    return [blockIndex, 0]
+  }
+
+  const childKey = getChildKeyFromSelectionPoint({
+    path,
+    offset: 0,
+  })
+
+  if (!childKey) {
+    return [blockIndex, 0]
   }
 
-  const childPath = [path[2]]
-  const childIndex = block.children.findIndex((child) =>
-    isEqual([{_key: child._key}], childPath),
-  )
+  let childPath: Array<number> = []
+  let childIndex = -1
 
-  if (childIndex >= 0 && block.children[childIndex]) {
-    const child = block.children[childIndex]
-    if (Element.isElement(child) && editor.isVoid(child)) {
-      return blockPath.concat(childIndex).concat(0)
+  for (const child of block.children) {
+    childIndex++
+    if (child._key === childKey) {
+      if (Element.isElement(child) && editor.isVoid(child)) {
+        childPath = [childIndex, 0]
+      } else {
+        childPath = [childIndex]
+      }
+      break
     }
-    return blockPath.concat(childIndex)
   }
 
-  return [blockPath[0], 0]
+  return [blockIndex].concat(childPath)
 }

package/src/internal-utils/ranges.ts

@@ -15,6 +15,7 @@ export function toSlateRange(
   if (!selection || !editor) {
     return null
   }
+
   const anchor = {
     path: toSlatePath(selection.anchor.path, editor),
     offset: selection.anchor.offset,
@@ -23,10 +24,13 @@ export function toSlateRange(
     path: toSlatePath(selection.focus.path, editor),
     offset: selection.focus.offset,
   }
+
   if (focus.path.length === 0 || anchor.path.length === 0) {
     return null
   }
+
   const range = anchor && focus ? {anchor, focus} : null
+
   return range
 }