@portabletext/editor 2.3.5 → 2.3.7

package/lib/plugins/index.d.cts

@@ -1,5 +1,5 @@
 import { Behavior, Editor, EditorEmittedEvent, EditorSchema } from "../_chunks-dts/behavior.types.action.cjs";
-import * as react12 from "react";
+import * as react22 from "react";
 import React from "react";
 /**
  * @beta
@@ -181,7 +181,7 @@ type MarkdownPluginConfig = MarkdownBehaviorsConfig & {
  */
 declare function MarkdownPlugin(props: {
   config: MarkdownPluginConfig;
-}): react12.JSX.Element;
+}): react22.JSX.Element;
 /**
  * @beta
  * Restrict the editor to one line. The plugin takes care of blocking
@@ -192,5 +192,5 @@ declare function MarkdownPlugin(props: {
  *
  * @deprecated Install the plugin from `@portabletext/plugin-one-line`
  */
-declare function OneLinePlugin(): react12.JSX.Element;
+declare function OneLinePlugin(): react22.JSX.Element;
 export { BehaviorPlugin, DecoratorShortcutPlugin, EditorRefPlugin, EventListenerPlugin, MarkdownPlugin, type MarkdownPluginConfig, OneLinePlugin };

package/lib/utils/index.d.ts

@@ -1,5 +1,5 @@
 import { BlockOffset, BlockPath, ChildPath, EditorContext, EditorSelection, EditorSelectionPoint } from "../_chunks-dts/behavior.types.action.js";
-import * as _sanity_types8 from "@sanity/types";
+import * as _sanity_types9 from "@sanity/types";
 import { KeyedSegment, PortableTextBlock, PortableTextChild, PortableTextSpan, PortableTextTextBlock } from "@sanity/types";
 /**
  * @public
@@ -150,7 +150,7 @@ declare function mergeTextBlocks({
   context: Pick<EditorContext, 'keyGenerator' | 'schema'>;
   targetBlock: PortableTextTextBlock;
   incomingBlock: PortableTextTextBlock;
-}): PortableTextTextBlock<_sanity_types8.PortableTextObject | _sanity_types8.PortableTextSpan>;
+}): PortableTextTextBlock<_sanity_types9.PortableTextObject | _sanity_types9.PortableTextSpan>;
 /**
  * @public
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "2.3.5",
+  "version": "2.3.7",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -79,18 +79,16 @@
     "slate-dom": "^0.117.4",
     "slate-react": "0.117.4",
     "xstate": "^5.20.2",
-    "@portabletext/block-tools": "3.0.0",
-    "@portabletext/patches": "1.1.6",
+    "@portabletext/block-tools": "3.2.0",
     "@portabletext/keyboard-shortcuts": "1.1.1",
-    "@portabletext/schema": "1.0.0",
-    "@portabletext/sanity-bridge": "1.1.0"
+    "@portabletext/patches": "1.1.6",
+    "@portabletext/schema": "1.0.0"
   },
   "devDependencies": {
-    "@portabletext/toolkit": "^2.0.17",
     "@sanity/diff-match-patch": "^3.2.0",
     "@sanity/pkg-utils": "^7.11.1",
-    "@sanity/schema": "^4.3.0",
-    "@sanity/types": "^4.3.0",
+    "@sanity/schema": "^4.4.1",
+    "@sanity/types": "^4.4.1",
     "@testing-library/react": "^16.3.0",
     "@types/debug": "^4.1.12",
     "@types/lodash": "^4.17.16",
@@ -113,13 +111,15 @@
     "vite": "^7.0.6",
     "vitest": "^3.2.4",
     "vitest-browser-react": "^1.0.1",
+    "@portabletext/sanity-bridge": "1.1.1",
     "racejar": "1.2.12"
   },
   "peerDependencies": {
-    "@sanity/schema": "^4.3.0",
-    "@sanity/types": "^4.3.0",
+    "@sanity/schema": "^4.4.1",
+    "@sanity/types": "^4.4.1",
     "react": "^18.3 || ^19",
-    "rxjs": "^7.8.2"
+    "rxjs": "^7.8.2",
+    "@portabletext/sanity-bridge": "1.1.1"
   },
   "engines": {
     "node": ">=20.19"

package/src/editor/__tests__/self-solving.test.tsx

@@ -1,4 +1,5 @@
 import type {JSONValue, Patch} from '@portabletext/patches'
+import {compileSchema, defineSchema} from '@portabletext/schema'
 import type {PortableTextBlock, PortableTextSpan} from '@sanity/types'
 import {render, waitFor} from '@testing-library/react'
 import {createRef, type ComponentProps, type RefObject} from 'react'
@@ -30,6 +31,7 @@ function span(
 
 describe('Feature: Self-solving', () => {
   it('Scenario: Missing .markDefs and .marks are added after the editor is made dirty', async () => {
+    const schemaDefinition = defineSchema({decorators: [{name: 'strong'}]})
     const editorRef: RefObject<PortableTextEditor | null> = createRef()
     const onChange = vi.fn<OnChange>()
     const initialValue = [
@@ -77,6 +79,7 @@ describe('Feature: Self-solving', () => {
     render(
       <PortableTextEditorTester
         ref={editorRef}
+        schemaDefinition={schemaDefinition}
         keyGenerator={createTestKeyGenerator()}
         value={initialValue}
         onChange={onChange}
@@ -99,7 +102,10 @@ describe('Feature: Self-solving', () => {
       if (editorRef.current) {
         PortableTextEditor.select(
           editorRef.current,
-          getTextSelection(initialValue, 'foo'),
+          getTextSelection(
+            {schema: compileSchema(schemaDefinition), value: initialValue},
+            'foo',
+          ),
         )
         PortableTextEditor.toggleMark(editorRef.current, 'strong')
       }
@@ -110,7 +116,10 @@ describe('Feature: Self-solving', () => {
         expect(onChange).toHaveBeenNthCalledWith(3, {
           type: 'selection',
           selection: {
-            ...getTextSelection(initialValue, 'foo'),
+            ...getTextSelection(
+              {schema: compileSchema(schemaDefinition), value: initialValue},
+              'foo',
+            ),
             backward: false,
           },
         })
@@ -129,7 +138,10 @@ describe('Feature: Self-solving', () => {
         expect(onChange).toHaveBeenNthCalledWith(7, {
           type: 'selection',
           selection: {
-            ...getTextSelection(initialValue, 'foo'),
+            ...getTextSelection(
+              {schema: compileSchema(schemaDefinition), value: initialValue},
+              'foo',
+            ),
             backward: false,
           },
         })

package/src/editor/plugins/createWithPortableTextMarkModel.ts

@@ -4,11 +4,11 @@
  *
  */
 
-import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
 import type {PortableTextObject, PortableTextSpan} from '@sanity/types'
 import {isEqual, uniq} from 'lodash'
 import {Editor, Element, Node, Path, Range, Text, Transforms} from 'slate'
 import {debugWithName} from '../../internal-utils/debug'
+import {isSpan, isTextBlock} from '../../internal-utils/parse-blocks'
 import {getNextSpan, getPreviousSpan} from '../../internal-utils/sibling-utils'
 import {isChangingRemotely} from '../../internal-utils/withChanges'
 import {isRedoing, isUndoing} from '../../internal-utils/withUndoRedo'
@@ -356,7 +356,7 @@ export function createWithPortableTextMarkModel(
 
           if (
             atTheEndOfAnnotation &&
-            isPortableTextSpan(op.node) &&
+            isSpan(editorActor.getSnapshot().context, op.node) &&
             op.node.marks?.some((mark) => annotationsEnding.includes(mark))
           ) {
             Transforms.insertNodes(editor, {
@@ -378,7 +378,7 @@ export function createWithPortableTextMarkModel(
 
           if (
             atTheStartOfAnnotation &&
-            isPortableTextSpan(op.node) &&
+            isSpan(editorActor.getSnapshot().context, op.node) &&
             op.node.marks?.some((mark) => annotationsStarting.includes(mark))
           ) {
             Transforms.insertNodes(editor, {
@@ -400,7 +400,7 @@ export function createWithPortableTextMarkModel(
             decoratorStarting &&
             atTheEndOfAnnotation &&
             !atTheStartOfAnnotation &&
-            isPortableTextSpan(op.node) &&
+            isSpan(editorActor.getSnapshot().context, op.node) &&
             op.node.marks?.length === 0
           ) {
             Transforms.insertNodes(editor, {
@@ -458,7 +458,11 @@ export function createWithPortableTextMarkModel(
               }),
             )[0] ?? ([undefined, undefined] as const)
 
-          if (span && block && isPortableTextBlock(block)) {
+          if (
+            span &&
+            block &&
+            isTextBlock(editorActor.getSnapshot().context, block)
+          ) {
             const markDefs = block.markDefs ?? []
             const marks = span.marks ?? []
             const spanHasAnnotations = marks.some((mark) =>

package/src/internal-utils/editor-selection.test.ts

@@ -1,7 +1,9 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
 import {expect, test} from 'vitest'
 import {getEditorSelection} from './editor-selection'
 
 test(getEditorSelection.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const image = {
     _type: 'image',
     _key: 'i1',
@@ -25,15 +27,17 @@ test(getEditorSelection.name, () => {
     ],
   }
 
-  expect(getEditorSelection([image, splitBlock])).toEqual({
+  expect(getEditorSelection({schema, value: [image, splitBlock]})).toEqual({
     anchor: {path: [{_key: 'i1'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
   })
-  expect(getEditorSelection([splitBlock, image])).toEqual({
+  expect(getEditorSelection({schema, value: [splitBlock, image]})).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
     focus: {path: [{_key: 'i1'}], offset: 0},
   })
-  expect(getEditorSelection([blockWithStockTicker, splitBlock])).toEqual({
+  expect(
+    getEditorSelection({schema, value: [blockWithStockTicker, splitBlock]}),
+  ).toEqual({
     anchor: {path: [{_key: 'b2'}, 'children', {_key: 's1'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
   })

package/src/internal-utils/editor-selection.ts

@@ -1,20 +1,16 @@
-import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
-import type {PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
 import type {EditorSelection, EditorSelectionPoint} from '../types/editor'
+import {isSpan, isTextBlock} from './parse-blocks'
 
 export function getEditorSelection(
-  blocks: Array<PortableTextBlock> | undefined,
+  context: Pick<EditorContext, 'schema' | 'value'>,
 ): EditorSelection {
-  if (!blocks) {
-    throw new Error('No value found')
-  }
-
   let anchor: EditorSelectionPoint | undefined
   let focus: EditorSelectionPoint | undefined
-  const firstBlock = blocks[0]
-  const lastBlock = blocks[blocks.length - 1]
+  const firstBlock = context.value[0]
+  const lastBlock = context.value[context.value.length - 1]
 
-  if (isPortableTextBlock(firstBlock)) {
+  if (isTextBlock(context, firstBlock)) {
     anchor = {
       path: [
         {_key: firstBlock._key},
@@ -30,13 +26,13 @@ export function getEditorSelection(
     }
   }
 
-  const lastChild = isPortableTextBlock(lastBlock)
+  const lastChild = isTextBlock(context, lastBlock)
     ? lastBlock.children[lastBlock.children.length - 1]
     : undefined
   if (
-    isPortableTextBlock(lastBlock) &&
+    isTextBlock(context, lastBlock) &&
     lastChild &&
-    isPortableTextSpan(lastChild)
+    isSpan(context, lastChild)
   ) {
     focus = {
       path: [{_key: lastBlock._key}, 'children', {_key: lastChild._key}],

package/src/internal-utils/selection-focus-text.ts

@@ -1,21 +1,19 @@
-import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
-import type {PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
 import {
   getBlockKeyFromSelectionPoint,
   getChildKeyFromSelectionPoint,
 } from '../selection/selection-point'
-import type {EditorSelection} from '../types/editor'
+import {isSpan, isTextBlock} from './parse-blocks'
 
 export function getSelectionFocusText(
-  value: Array<PortableTextBlock> | undefined,
-  selection: EditorSelection,
+  context: Pick<EditorContext, 'schema' | 'value' | 'selection'>,
 ) {
-  if (!value || !selection) {
+  if (!context.selection) {
     return undefined
   }
 
-  const focusBlockKey = getBlockKeyFromSelectionPoint(selection.focus)
-  const focusChildKey = getChildKeyFromSelectionPoint(selection.focus)
+  const focusBlockKey = getBlockKeyFromSelectionPoint(context.selection.focus)
+  const focusChildKey = getChildKeyFromSelectionPoint(context.selection.focus)
 
   if (focusBlockKey === undefined || focusChildKey === undefined) {
     return undefined
@@ -23,11 +21,11 @@ export function getSelectionFocusText(
 
   let text: string | undefined
 
-  for (const block of value) {
-    if (isPortableTextBlock(block)) {
+  for (const block of context.value) {
+    if (isTextBlock(context, block)) {
       if (block._key === focusBlockKey) {
         for (const child of block.children) {
-          if (isPortableTextSpan(child)) {
+          if (isSpan(context, child)) {
             if (child._key === focusChildKey) {
               text = child.text
               break

package/src/internal-utils/selection-text.test.ts

@@ -1,7 +1,9 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
 import {expect, test} from 'vitest'
 import {getSelectionText} from './selection-text'
 
 test(getSelectionText.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const splitBlock = {
     _type: 'block',
     _key: 'A-4',
@@ -15,9 +17,13 @@ test(getSelectionText.name, () => {
   }
 
   expect(
-    getSelectionText([splitBlock], {
-      anchor: {path: [{_key: 'A-4'}, 'children', {_key: 'A-7'}], offset: 0},
-      focus: {path: [{_key: 'A-4'}, 'children', {_key: 'A-7'}], offset: 3},
+    getSelectionText({
+      schema,
+      value: [splitBlock],
+      selection: {
+        anchor: {path: [{_key: 'A-4'}, 'children', {_key: 'A-7'}], offset: 0},
+        focus: {path: [{_key: 'A-4'}, 'children', {_key: 'A-7'}], offset: 3},
+      },
     }),
   ).toEqual(['bar'])
 })

package/src/internal-utils/selection-text.ts

@@ -1,21 +1,18 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorSelection} from '../types/editor'
+import type {EditorContext} from '../editor/editor-snapshot'
 import {sliceBlocks} from '../utils/util.slice-blocks'
 import {getTersePt} from './terse-pt'
 
 export function getSelectionText(
-  value: Array<PortableTextBlock> | undefined,
-  selection: EditorSelection,
+  context: Pick<EditorContext, 'schema' | 'value' | 'selection'>,
 ) {
-  if (!value || !selection) {
+  if (!context.selection) {
     return []
   }
 
   const slice = sliceBlocks({
-    context: {schema: compileSchema(defineSchema({})), selection},
-    blocks: value,
+    context: {schema: context.schema, selection: context.selection},
+    blocks: context.value,
   })
 
-  return getTersePt(slice)
+  return getTersePt({schema: context.schema, value: slice})
 }

package/src/internal-utils/terse-pt.test.ts

@@ -6,6 +6,7 @@ import {getTersePt, parseTersePt, parseTersePtString} from './terse-pt'
 const keyGenerator = createTestKeyGenerator()
 
 test(getTersePt.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const fooBlock = {
     _key: 'b1',
     _type: 'block',
@@ -27,66 +28,88 @@ test(getTersePt.name, () => {
     children: [{_key: 's4', _type: 'span', text: 'foo\nbar'}],
   }
 
-  expect(getTersePt([fooBlock, barBlock])).toEqual(['foo', 'bar'])
-  expect(getTersePt([emptyBlock, barBlock])).toEqual(['', 'bar'])
-  expect(getTersePt([fooBlock, emptyBlock, barBlock])).toEqual([
+  expect(getTersePt({schema, value: [fooBlock, barBlock]})).toEqual([
     'foo',
+    'bar',
+  ])
+  expect(getTersePt({schema, value: [emptyBlock, barBlock]})).toEqual([
     '',
     'bar',
   ])
-  expect(getTersePt([fooBlock, softReturnBlock])).toEqual(['foo', 'foo\nbar'])
+  expect(getTersePt({schema, value: [fooBlock, emptyBlock, barBlock]})).toEqual(
+    ['foo', '', 'bar'],
+  )
+  expect(getTersePt({schema, value: [fooBlock, softReturnBlock]})).toEqual([
+    'foo',
+    'foo\nbar',
+  ])
 
   expect(
-    getTersePt([
-      {
-        _key: keyGenerator(),
-        _type: 'block',
-        children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
-      },
-    ]),
+    getTersePt({
+      schema,
+      value: [
+        {
+          _key: keyGenerator(),
+          _type: 'block',
+          children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
+        },
+      ],
+    }),
   ).toEqual(['foo'])
   expect(
-    getTersePt([
-      {
-        _key: keyGenerator(),
-        _type: 'block',
-        children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
-        listItem: 'number',
-      },
-    ]),
+    getTersePt({
+      schema,
+      value: [
+        {
+          _key: keyGenerator(),
+          _type: 'block',
+          children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
+          listItem: 'number',
+        },
+      ],
+    }),
   ).toEqual(['#:foo'])
   expect(
-    getTersePt([
-      {
-        _key: keyGenerator(),
-        _type: 'block',
-        children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
-        listItem: 'number',
-        style: 'h3',
-      },
-    ]),
+    getTersePt({
+      schema,
+      value: [
+        {
+          _key: keyGenerator(),
+          _type: 'block',
+          children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
+          listItem: 'number',
+          style: 'h3',
+        },
+      ],
+    }),
   ).toEqual(['#h3:foo'])
   expect(
-    getTersePt([
-      {
-        _key: keyGenerator(),
-        _type: 'block',
-        children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
-        level: 2,
-        listItem: 'number',
-        style: 'h3',
-      },
-    ]),
+    getTersePt({
+      schema,
+      value: [
+        {
+          _key: keyGenerator(),
+          _type: 'block',
+          children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
+          level: 2,
+          listItem: 'number',
+          style: 'h3',
+        },
+      ],
+    }),
   ).toEqual(['>>#h3:foo'])
   expect(
-    getTersePt([
-      {
-        _key: keyGenerator(),
-        _type: 'block',
-        children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
-        style: 'h3',
-      },
-    ]),
+    getTersePt({
+      schema,
+      value: [
+        {
+          _key: keyGenerator(),
+          _type: 'block',
+          children: [{_key: keyGenerator(), _type: 'span', text: 'foo'}],
+          style: 'h3',
+        },
+      ],
+    }),
   ).toEqual(['h3:foo'])
 })
 

package/src/internal-utils/terse-pt.ts

@@ -1,6 +1,6 @@
-import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
 import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
 import type {EditorContext} from '../editor/editor-snapshot'
+import {isSpan, isTextBlock} from './parse-blocks'
 
 type TersePtConfig = {
   style: (name?: string) => string
@@ -20,18 +20,14 @@ const defaultConfig: TersePtConfig = {
 }
 
 export function getTersePt(
-  value: Array<PortableTextBlock> | undefined,
+  context: Pick<EditorContext, 'schema' | 'value'>,
 ): Array<string> {
-  if (!value) {
-    return []
-  }
-
   const blocks: Array<string> = []
 
-  for (const block of value) {
+  for (const block of context.value) {
     let terseBlock = ''
 
-    if (isPortableTextBlock(block)) {
+    if (isTextBlock(context, block)) {
       const blockPrefix = `${defaultConfig.level(block.level)}${defaultConfig.listItem(block.listItem)}${defaultConfig.style(block.style)}`
 
       if (blockPrefix) {
@@ -42,7 +38,7 @@ export function getTersePt(
       for (const child of block.children) {
         index++
 
-        if (isPortableTextSpan(child)) {
+        if (isSpan(context, child)) {
           terseBlock = `${terseBlock}${index > 0 ? ',' : ''}${child.text}`
         } else {
           terseBlock = `${terseBlock}${index > 0 ? ',' : ''}{${child._type}}`

package/src/internal-utils/text-block-key.test.ts

@@ -1,7 +1,9 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
 import {expect, test} from 'vitest'
 import {getTextBlockKey} from './text-block-key'
 
 test(getTextBlockKey.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const emptyBlock = {
     _key: 'b1',
     _type: 'block',
@@ -18,13 +20,22 @@ test(getTextBlockKey.name, () => {
     children: [{_key: 's3', _type: 'span', text: 'foo\nbar'}],
   }
 
-  expect(getTextBlockKey([emptyBlock, fooBlock, softReturnBlock], '')).toBe(
-    'b1',
-  )
-  expect(getTextBlockKey([emptyBlock, fooBlock, softReturnBlock], 'foo')).toBe(
-    'b2',
-  )
   expect(
-    getTextBlockKey([emptyBlock, fooBlock, softReturnBlock], 'foo\nbar'),
+    getTextBlockKey(
+      {schema, value: [emptyBlock, fooBlock, softReturnBlock]},
+      '',
+    ),
+  ).toBe('b1')
+  expect(
+    getTextBlockKey(
+      {schema, value: [emptyBlock, fooBlock, softReturnBlock]},
+      'foo',
+    ),
+  ).toBe('b2')
+  expect(
+    getTextBlockKey(
+      {schema, value: [emptyBlock, fooBlock, softReturnBlock]},
+      'foo\nbar',
+    ),
   ).toBe('b3')
 })

package/src/internal-utils/text-block-key.ts

@@ -1,20 +1,16 @@
-import {isPortableTextBlock} from '@portabletext/toolkit'
-import {isPortableTextSpan, type PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
+import {isSpan, isTextBlock} from './parse-blocks'
 
 export function getTextBlockKey(
-  value: Array<PortableTextBlock> | undefined,
+  context: Pick<EditorContext, 'schema' | 'value'>,
   text: string,
 ) {
-  if (!value) {
-    throw new Error(`Unable to find block key for text "${text}"`)
-  }
-
   let blockKey: string | undefined
 
-  for (const block of value) {
-    if (isPortableTextBlock(block)) {
+  for (const block of context.value) {
+    if (isTextBlock(context, block)) {
       for (const child of block.children) {
-        if (isPortableTextSpan(child) && child.text === text) {
+        if (isSpan(context, child) && child.text === text) {
           blockKey = block._key
           break
         }

package/src/internal-utils/text-marks.test.ts

@@ -1,7 +1,9 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
 import {expect, test} from 'vitest'
 import {getTextMarks} from './text-marks'
 
 test(getTextMarks.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const fooBlock = {
     _key: 'b1',
     _type: 'block',
@@ -26,8 +28,14 @@ test(getTextMarks.name, () => {
     ],
   }
 
-  expect(getTextMarks([fooBlock, splitBarBlock], 'ba')).toEqual(['strong'])
-  expect(getTextMarks([splitFooBarBazBlock], 'bar')).toEqual(['strong'])
-  expect(getTextMarks([splitFooBarBazBlock], ' ')).toEqual([])
-  expect(getTextMarks([splitFooBarBazBlock], 'baz')).toEqual(['l1'])
+  expect(
+    getTextMarks({schema, value: [fooBlock, splitBarBlock]}, 'ba'),
+  ).toEqual(['strong'])
+  expect(getTextMarks({schema, value: [splitFooBarBazBlock]}, 'bar')).toEqual([
+    'strong',
+  ])
+  expect(getTextMarks({schema, value: [splitFooBarBazBlock]}, ' ')).toEqual([])
+  expect(getTextMarks({schema, value: [splitFooBarBazBlock]}, 'baz')).toEqual([
+    'l1',
+  ])
 })