@portabletext/editor 2.3.6 → 2.3.7

package/src/internal-utils/text-marks.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 {isSpan, isTextBlock} from './parse-blocks'
 
 export function getTextMarks(
-  value: Array<PortableTextBlock> | undefined,
+  context: Pick<EditorContext, 'schema' | 'value'>,
   text: string,
 ) {
-  if (!value) {
-    return undefined
-  }
-
   let marks: Array<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) {
           marks = child.marks ?? []
           break
         }

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

@@ -1,3 +1,4 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
 import {expect, test} from 'vitest'
 import {
   getSelectionAfterText,
@@ -6,13 +7,14 @@ import {
 } from './text-selection'
 
 test(getTextSelection.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const simpleBlock = {
     _key: 'b1',
     _type: 'block',
     children: [{_key: 's1', _type: 'span', text: 'foo'}],
   }
 
-  expect(getTextSelection([simpleBlock], 'foo')).toEqual({
+  expect(getTextSelection({schema, value: [simpleBlock]}, 'foo')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 3},
   })
@@ -23,19 +25,19 @@ test(getTextSelection.name, () => {
     children: [{_key: 's1', _type: 'span', text: 'foo bar baz'}],
   }
 
-  expect(getTextSelection([joinedBlock], 'foo ')).toEqual({
+  expect(getTextSelection({schema, value: [joinedBlock]}, 'foo ')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
   })
-  expect(getTextSelection([joinedBlock], 'o')).toEqual({
+  expect(getTextSelection({schema, value: [joinedBlock]}, 'o')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 2},
   })
-  expect(getTextSelection([joinedBlock], 'bar')).toEqual({
+  expect(getTextSelection({schema, value: [joinedBlock]}, 'bar')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 7},
   })
-  expect(getTextSelection([joinedBlock], ' baz')).toEqual({
+  expect(getTextSelection({schema, value: [joinedBlock]}, ' baz')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 7},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 11},
   })
@@ -49,7 +51,7 @@ test(getTextSelection.name, () => {
     ],
   }
 
-  expect(getTextSelection([noSpaceBlock], 'obar')).toEqual({
+  expect(getTextSelection({schema, value: [noSpaceBlock]}, 'obar')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 2},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
   })
@@ -64,10 +66,12 @@ test(getTextSelection.name, () => {
     ],
   }
 
-  expect(getTextSelection([emptyLineBlock], 'foobar')).toEqual({
-    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
-    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 3},
-  })
+  expect(getTextSelection({schema, value: [emptyLineBlock]}, 'foobar')).toEqual(
+    {
+      anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+      focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 3},
+    },
+  )
 
   const splitBlock = {
     _key: 'b1',
@@ -79,23 +83,25 @@ test(getTextSelection.name, () => {
     ],
   }
 
-  expect(getTextSelection([splitBlock], 'foo')).toEqual({
+  expect(getTextSelection({schema, value: [splitBlock]}, 'foo')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 3},
   })
-  expect(getTextSelection([splitBlock], 'bar')).toEqual({
+  expect(getTextSelection({schema, value: [splitBlock]}, 'bar')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
   })
-  expect(getTextSelection([splitBlock], 'baz')).toEqual({
+  expect(getTextSelection({schema, value: [splitBlock]}, 'baz')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 1},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
   })
-  expect(getTextSelection([splitBlock], 'foo bar baz')).toEqual({
+  expect(
+    getTextSelection({schema, value: [splitBlock]}, 'foo bar baz'),
+  ).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
   })
-  expect(getTextSelection([splitBlock], 'o bar b')).toEqual({
+  expect(getTextSelection({schema, value: [splitBlock]}, 'o bar b')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 2},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 2},
   })
@@ -113,13 +119,14 @@ test(getTextSelection.name, () => {
     },
   ]
 
-  expect(getTextSelection(twoBlocks, 'ooba')).toEqual({
+  expect(getTextSelection({schema, value: twoBlocks}, 'ooba')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
     focus: {path: [{_key: 'b2'}, 'children', {_key: 's2'}], offset: 2},
   })
 })
 
 test(getSelectionBeforeText.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const splitBlock = {
     _type: 'block',
     _key: 'b1',
@@ -130,34 +137,39 @@ test(getSelectionBeforeText.name, () => {
     ],
   }
 
-  expect(getSelectionBeforeText([splitBlock], 'foo ')).toEqual({
-    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
-    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
-    backward: false,
-  })
-  expect(getSelectionBeforeText([splitBlock], 'f')).toEqual({
+  expect(getSelectionBeforeText({schema, value: [splitBlock]}, 'foo ')).toEqual(
+    {
+      anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+      focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+      backward: false,
+    },
+  )
+  expect(getSelectionBeforeText({schema, value: [splitBlock]}, 'f')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
     backward: false,
   })
-  expect(getSelectionBeforeText([splitBlock], 'o')).toEqual({
+  expect(getSelectionBeforeText({schema, value: [splitBlock]}, 'o')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
     backward: false,
   })
-  expect(getSelectionBeforeText([splitBlock], 'bar')).toEqual({
+  expect(getSelectionBeforeText({schema, value: [splitBlock]}, 'bar')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 0},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 0},
     backward: false,
   })
-  expect(getSelectionBeforeText([splitBlock], ' baz')).toEqual({
-    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 0},
-    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 0},
-    backward: false,
-  })
+  expect(getSelectionBeforeText({schema, value: [splitBlock]}, ' baz')).toEqual(
+    {
+      anchor: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 0},
+      focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 0},
+      backward: false,
+    },
+  )
 })
 
 test(getSelectionAfterText.name, () => {
+  const schema = compileSchema(defineSchema({}))
   const splitBlock = {
     _type: 'block',
     _key: 'b1',
@@ -168,17 +180,17 @@ test(getSelectionAfterText.name, () => {
     ],
   }
 
-  expect(getSelectionAfterText([splitBlock], 'foo ')).toEqual({
+  expect(getSelectionAfterText({schema, value: [splitBlock]}, 'foo ')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
     backward: false,
   })
-  expect(getSelectionAfterText([splitBlock], 'bar')).toEqual({
+  expect(getSelectionAfterText({schema, value: [splitBlock]}, 'bar')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
     backward: false,
   })
-  expect(getSelectionAfterText([splitBlock], ' baz')).toEqual({
+  expect(getSelectionAfterText({schema, value: [splitBlock]}, ' baz')).toEqual({
     anchor: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
     focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
     backward: false,

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

@@ -1,25 +1,21 @@
-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 {collapseSelection} from './collapse-selection'
+import {isSpan, isTextBlock} from './parse-blocks'
 import {splitString} from './split-string'
 import {stringOverlap} from './string-overlap'
 
 export function getTextSelection(
-  value: Array<PortableTextBlock> | undefined,
+  context: Pick<EditorContext, 'schema' | 'value'>,
   text: string,
 ): EditorSelection {
-  if (!value) {
-    throw new Error(`Unable to find selection for value ${value}`)
-  }
-
   let anchor: EditorSelectionPoint | undefined
   let focus: EditorSelectionPoint | 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)) {
+        if (isSpan(context, child)) {
           if (child.text === text) {
             anchor = {
               path: [{_key: block._key}, 'children', {_key: child._key}],
@@ -99,7 +95,7 @@ export function getTextSelection(
 
   if (!anchor || !focus) {
     throw new Error(
-      `Unable to find selection for text "${text}" in value "${JSON.stringify(value)}"`,
+      `Unable to find selection for text "${text}" in value "${JSON.stringify(context.value)}"`,
     )
   }
 
@@ -110,15 +106,15 @@ export function getTextSelection(
 }
 
 export function getSelectionBeforeText(
-  value: Array<PortableTextBlock> | undefined,
+  context: Pick<EditorContext, 'schema' | 'value'>,
   text: string,
 ): EditorSelection {
-  return collapseSelection(getTextSelection(value, text), 'start')
+  return collapseSelection(getTextSelection(context, text), 'start')
 }
 
 export function getSelectionAfterText(
-  value: Array<PortableTextBlock> | undefined,
+  context: Pick<EditorContext, 'schema' | 'value'>,
   text: string,
 ): EditorSelection {
-  return collapseSelection(getTextSelection(value, text), 'end')
+  return collapseSelection(getTextSelection(context, text), 'end')
 }

package/src/internal-utils/value-annotations.ts

@@ -1,7 +1,9 @@
-import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
 import type {PortableTextBlock} from '@sanity/types'
+import type {EditorSchema} from '../editor/editor-schema'
+import {isSpan, isTextBlock} from './parse-blocks'
 
 export function getValueAnnotations(
+  schema: EditorSchema,
   value: Array<PortableTextBlock> | undefined,
 ): Array<string> {
   if (!value) {
@@ -11,9 +13,9 @@ export function getValueAnnotations(
   const annotations: Array<string> = []
 
   for (const block of value) {
-    if (isPortableTextBlock(block)) {
+    if (isTextBlock({schema}, block)) {
       for (const child of block.children) {
-        if (isPortableTextSpan(child) && child.marks) {
+        if (isSpan({schema}, child) && child.marks) {
           for (const mark of child.marks) {
             if (
               block.markDefs?.some((markDef) => markDef._key === mark) &&

package/src/plugins/plugin.internal.auto-close-brackets.test.tsx

@@ -33,33 +33,33 @@ describe(AutoCloseBracketsPlugin.name, () => {
     editorRef.current?.send({type: 'insert.text', text: '('})
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['()'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '()',
+      ])
     })
 
     await userEvent.type(locator, 'foo')
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['(foo)'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '(foo)',
+      ])
     })
 
     editorRef.current?.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['()'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '()',
+      ])
     })
 
     editorRef.current?.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['('])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '(',
+      ])
     })
   })
 
@@ -86,33 +86,33 @@ describe(AutoCloseBracketsPlugin.name, () => {
     editorRef.current?.send({type: 'insert.text', text: '(f'})
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['(f)'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '(f)',
+      ])
     })
 
     await userEvent.type(locator, 'oo')
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['(foo)'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '(foo)',
+      ])
     })
 
     editorRef.current?.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['(f)'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '(f)',
+      ])
     })
 
     editorRef.current?.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['(f'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '(f',
+      ])
     })
   })
 })

package/src/plugins/plugin.markdown.test.tsx

@@ -39,26 +39,23 @@ describe(MarkdownPlugin.name, () => {
     await userEvent.type(locator, '**Hello world!**')
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['Hello world!'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        'Hello world!',
+      ])
     })
 
     await vi.waitFor(() => {
       expect(
-        getTextMarks(
-          editorRef.current!.getSnapshot().context.value,
-          'Hello world!',
-        ),
+        getTextMarks(editorRef.current!.getSnapshot().context, 'Hello world!'),
       ).toEqual(['strong'])
     })
 
     editorRef.current?.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(
-        getTersePt(editorRef.current?.getSnapshot().context.value),
-      ).toEqual(['**Hello world!**'])
+      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+        '**Hello world!**',
+      ])
     })
   })
 })