@portabletext/editor 2.8.0 → 2.8.2

package/src/operations/behavior.operation.annotation.add.ts

@@ -1,29 +1,9 @@
-import type {Path} from '@sanity/types'
 import {Editor, Node, Range, Text, Transforms} from 'slate'
 import {parseAnnotation} from '../internal-utils/parse-blocks'
 import type {BehaviorOperationImplementation} from './behavior.operations'
 
-/**
- * @public
- */
-export type AddedAnnotationPaths = {
-  /**
-   * @deprecated An annotation may be applied to multiple blocks, resulting
-   * in multiple `markDef`'s being created. Use `markDefPaths` instead.
-   */
-  markDefPath: Path
-  markDefPaths: Array<Path>
-  /**
-   * @deprecated Does not return anything meaningful since an annotation
-   * can span multiple blocks and spans. If references the span closest
-   * to the focus point of the selection.
-   */
-  spanPath: Path
-}
-
 export const addAnnotationOperationImplementation: BehaviorOperationImplementation<
-  'annotation.add',
-  AddedAnnotationPaths | undefined
+  'annotation.add'
 > = ({context, operation}) => {
   const parsedAnnotation = parseAnnotation({
     annotation: {
@@ -31,7 +11,7 @@ export const addAnnotationOperationImplementation: BehaviorOperationImplementati
       ...operation.annotation.value,
     },
     context,
-    options: {refreshKeys: false, validateFields: true},
+    options: {validateFields: true},
   })
 
   if (!parsedAnnotation) {
@@ -46,11 +26,6 @@ export const addAnnotationOperationImplementation: BehaviorOperationImplementati
     return
   }
 
-  let paths: AddedAnnotationPaths | undefined
-  let spanPath: Path | undefined
-  let markDefPath: Path | undefined
-  const markDefPaths: Path[] = []
-
   const selectedBlocks = Editor.nodes(editor, {
     at: editor.selection,
     match: (node) => editor.isTextBlock(node),
@@ -92,14 +67,6 @@ export const addAnnotationOperationImplementation: BehaviorOperationImplementati
         },
         {at: blockPath},
       )
-
-      markDefPath = [{_key: block._key}, 'markDefs', {_key: annotationKey}]
-
-      if (Range.isBackward(editor.selection)) {
-        markDefPaths.unshift(markDefPath)
-      } else {
-        markDefPaths.push(markDefPath)
-      }
     }
 
     Transforms.setNodes(editor, {}, {match: Text.isText, split: true})
@@ -124,20 +91,8 @@ export const addAnnotationOperationImplementation: BehaviorOperationImplementati
         },
         {at: path},
       )
-
-      spanPath = [{_key: block._key}, 'children', {_key: span._key}]
     }
 
     blockIndex++
   }
-
-  if (markDefPath && spanPath) {
-    paths = {
-      markDefPath,
-      markDefPaths,
-      spanPath,
-    }
-  }
-
-  return paths
 }

package/src/operations/behavior.operation.block.set.ts

@@ -51,7 +51,7 @@ export const blockSetOperationImplementation: BehaviorOperationImplementation<
       ...parsedBlock,
       ...filteredProps,
     },
-    options: {refreshKeys: false, validateFields: true},
+    options: {validateFields: true},
   })
 
   if (!updatedBlock) {

package/src/operations/behavior.operation.block.unset.ts

@@ -51,7 +51,7 @@ export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
     const updatedTextBlock = parseBlock({
       context,
       block: omit(parsedBlock, propsToRemove),
-      options: {refreshKeys: false, validateFields: true},
+      options: {validateFields: true},
     })
 
     if (!updatedTextBlock) {
@@ -81,7 +81,7 @@ export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
       parsedBlock,
       operation.props.filter((prop) => prop !== '_type'),
     ),
-    options: {refreshKeys: false, validateFields: true},
+    options: {validateFields: true},
   })
 
   if (!updatedBlockObject) {

package/src/operations/behavior.operation.insert.block.ts

@@ -24,7 +24,7 @@ export const insertBlockOperationImplementation: BehaviorOperationImplementation
   const parsedBlock = parseBlock({
     block: operation.block,
     context,
-    options: {refreshKeys: false, validateFields: true},
+    options: {validateFields: true},
   })
 
   if (!parsedBlock) {

package/src/operations/behavior.operations.ts

@@ -32,14 +32,13 @@ export type BehaviorOperationImplementationContext = Pick<
 
 export type BehaviorOperationImplementation<
   TBehaviorOperationType extends BehaviorOperation['type'],
-  TReturnType = void,
 > = ({
   context,
   operation,
 }: {
   context: BehaviorOperationImplementationContext
   operation: PickFromUnion<BehaviorOperation, 'type', TBehaviorOperationType>
-}) => TReturnType
+}) => void
 
 type BehaviorOperation = OmitFromUnion<
   SyntheticBehaviorEvent,

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

@@ -1,117 +1,71 @@
-import {defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator, getTersePt} from '@portabletext/test'
-import {page, userEvent} from '@vitest/browser/context'
-import React from 'react'
+import {getTersePt} from '@portabletext/test'
+import {userEvent} from '@vitest/browser/context'
 import {describe, expect, test, vi} from 'vitest'
-import {render} from 'vitest-browser-react'
-import {EditorProvider, PortableTextEditable, type Editor} from '..'
-import {EditorRefPlugin} from './plugin.editor-ref'
+import {createTestEditor} from '../internal-utils/test-editor'
 import {AutoCloseBracketsPlugin} from './plugin.internal.auto-close-brackets'
 
 describe(AutoCloseBracketsPlugin.name, () => {
   test('One-character text insertion', async () => {
-    const editorRef = React.createRef<Editor>()
-
-    render(
-      <EditorProvider
-        initialConfig={{
-          keyGenerator: createTestKeyGenerator(),
-          schemaDefinition: defineSchema({}),
-        }}
-      >
-        <EditorRefPlugin ref={editorRef} />
-        <PortableTextEditable />
-        <AutoCloseBracketsPlugin />
-      </EditorProvider>,
-    )
-
-    const locator = page.getByRole('textbox')
-    await vi.waitFor(() => expect.element(locator).toBeInTheDocument())
+    const {editor, locator} = await createTestEditor({
+      children: <AutoCloseBracketsPlugin />,
+    })
+
     await userEvent.click(locator)
 
-    editorRef.current?.send({type: 'insert.text', text: '('})
+    editor.send({type: 'insert.text', text: '('})
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '()',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['()'])
     })
 
     await userEvent.type(locator, 'foo')
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '(foo)',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(foo)'])
     })
 
-    editorRef.current?.send({type: 'history.undo'})
+    editor.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '()',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['()'])
     })
 
-    editorRef.current?.send({type: 'history.undo'})
+    editor.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '(',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['('])
     })
   })
 
   test('Two-character text insertion', async () => {
-    const editorRef = React.createRef<Editor>()
-
-    render(
-      <EditorProvider
-        initialConfig={{
-          keyGenerator: createTestKeyGenerator(),
-          schemaDefinition: defineSchema({}),
-        }}
-      >
-        <EditorRefPlugin ref={editorRef} />
-        <PortableTextEditable />
-        <AutoCloseBracketsPlugin />
-      </EditorProvider>,
-    )
-
-    const locator = page.getByRole('textbox')
-    await vi.waitFor(() => expect.element(locator).toBeInTheDocument())
+    const {editor, locator} = await createTestEditor({
+      children: <AutoCloseBracketsPlugin />,
+    })
+
     await userEvent.click(locator)
 
-    editorRef.current?.send({type: 'insert.text', text: '(f'})
+    editor.send({type: 'insert.text', text: '(f'})
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '(f)',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(f)'])
     })
 
     await userEvent.type(locator, 'oo')
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '(foo)',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(foo)'])
     })
 
-    editorRef.current?.send({type: 'history.undo'})
+    editor.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '(f)',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(f)'])
     })
 
-    editorRef.current?.send({type: 'history.undo'})
+    editor.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        '(f',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['(f'])
     })
   })
 })

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

@@ -1,58 +1,40 @@
 import {defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator, getTersePt} from '@portabletext/test'
-import {page, userEvent} from '@vitest/browser/context'
-import React from 'react'
+import {getTersePt} from '@portabletext/test'
+import {userEvent} from '@vitest/browser/context'
 import {describe, expect, test, vi} from 'vitest'
-import {render} from 'vitest-browser-react'
-import {PortableTextEditable, type Editor} from '..'
-import {EditorProvider} from '../editor/editor-provider'
+import {createTestEditor} from '../internal-utils/test-editor'
 import {getTextMarks} from '../internal-utils/text-marks'
-import {EditorRefPlugin} from './plugin.editor-ref'
 import {MarkdownPlugin} from './plugin.markdown'
 
 describe(MarkdownPlugin.name, () => {
   test('Scenario: Undoing bold shortcut', async () => {
-    const editorRef = React.createRef<Editor>()
-
-    render(
-      <EditorProvider
-        initialConfig={{
-          keyGenerator: createTestKeyGenerator(),
-          schemaDefinition: defineSchema({decorators: [{name: 'strong'}]}),
-        }}
-      >
-        <EditorRefPlugin ref={editorRef} />
-        <PortableTextEditable />
+    const {editor, locator} = await createTestEditor({
+      children: (
         <MarkdownPlugin
           config={{
             boldDecorator: () => 'strong',
           }}
         />
-      </EditorProvider>,
-    )
-
-    const locator = page.getByRole('textbox')
-
-    await vi.waitFor(() => expect.element(locator).toBeInTheDocument())
+      ),
+      schemaDefinition: defineSchema({decorators: [{name: 'strong'}]}),
+    })
 
     await userEvent.type(locator, '**Hello world!**')
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
-        'Hello world!',
-      ])
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['Hello world!'])
     })
 
     await vi.waitFor(() => {
       expect(
-        getTextMarks(editorRef.current!.getSnapshot().context, 'Hello world!'),
+        getTextMarks(editor.getSnapshot().context, 'Hello world!'),
       ).toEqual(['strong'])
     })
 
-    editorRef.current?.send({type: 'history.undo'})
+    editor.send({type: 'history.undo'})
 
     await vi.waitFor(() => {
-      expect(getTersePt(editorRef.current!.getSnapshot().context)).toEqual([
+      expect(getTersePt(editor.getSnapshot().context)).toEqual([
         '**Hello world!**',
       ])
     })