@portabletext/editor 2.7.1 → 2.8.0

package/src/editor/plugins/__tests__/withUndoRedo.test.tsx

@@ -1,147 +0,0 @@
-import {createTestKeyGenerator} from '@portabletext/test'
-import {render, waitFor} from '@testing-library/react'
-import {createRef, type RefObject} from 'react'
-import {describe, expect, it, vi} from 'vitest'
-import {PortableTextEditorTester} from '../../__tests__/PortableTextEditorTester'
-import {PortableTextEditor} from '../../PortableTextEditor'
-
-const initialValue = [
-  {
-    _key: 'a',
-    _type: 'block',
-    children: [
-      {
-        _key: 'a1',
-        _type: 'span',
-        marks: [],
-        text: 'Block A',
-      },
-    ],
-    markDefs: [],
-    style: 'normal',
-  },
-  {
-    _key: 'b',
-    _type: 'block',
-    children: [
-      {
-        _key: 'b1',
-        _type: 'span',
-        marks: [],
-        text: 'Block B',
-      },
-    ],
-    markDefs: [],
-    style: 'normal',
-  },
-]
-
-const initialSelection = {
-  focus: {path: [{_key: 'b'}, 'children', {_key: 'b1'}], offset: 7},
-  anchor: {path: [{_key: 'b'}, 'children', {_key: 'b1'}], offset: 7},
-}
-
-describe('plugin:withUndoRedo', () => {
-  it('preserves the keys when undoing ', async () => {
-    const editorRef: RefObject<PortableTextEditor | null> = createRef()
-    const onChange = vi.fn()
-    render(
-      <PortableTextEditorTester
-        keyGenerator={createTestKeyGenerator()}
-        onChange={onChange}
-        ref={editorRef}
-        value={initialValue}
-      />,
-    )
-
-    await waitFor(() => {
-      if (editorRef.current) {
-        expect(onChange).toHaveBeenCalledWith({
-          type: 'value',
-          value: initialValue,
-        })
-        expect(onChange).toHaveBeenCalledWith({type: 'ready'})
-      }
-    })
-
-    await waitFor(() => {
-      if (editorRef.current) {
-        PortableTextEditor.focus(editorRef.current)
-        PortableTextEditor.select(editorRef.current, initialSelection)
-        PortableTextEditor.delete(
-          editorRef.current,
-          PortableTextEditor.getSelection(editorRef.current),
-          {mode: 'blocks'},
-        )
-        expect(PortableTextEditor.getValue(editorRef.current))
-          .toMatchInlineSnapshot(`
-          [
-            {
-              "_key": "a",
-              "_type": "block",
-              "children": [
-                {
-                  "_key": "a1",
-                  "_type": "span",
-                  "marks": [],
-                  "text": "Block A",
-                },
-              ],
-              "markDefs": [],
-              "style": "normal",
-            },
-          ]
-        `)
-        PortableTextEditor.undo(editorRef.current)
-        expect(PortableTextEditor.getValue(editorRef.current)).toEqual(
-          initialValue,
-        )
-      }
-    })
-  })
-  it('preserves the keys when redoing ', async () => {
-    const editorRef: RefObject<PortableTextEditor | null> = createRef()
-    const onChange = vi.fn()
-
-    render(
-      <PortableTextEditorTester
-        keyGenerator={createTestKeyGenerator()}
-        onChange={onChange}
-        ref={editorRef}
-        value={initialValue}
-      />,
-    )
-
-    await waitFor(() => {
-      if (editorRef.current) {
-        expect(onChange).toHaveBeenCalledWith({
-          type: 'value',
-          value: initialValue,
-        })
-        expect(onChange).toHaveBeenCalledWith({type: 'ready'})
-      }
-    })
-
-    await waitFor(() => {
-      if (editorRef.current) {
-        PortableTextEditor.focus(editorRef.current)
-        PortableTextEditor.select(editorRef.current, initialSelection)
-        PortableTextEditor.insertBlock(
-          editorRef.current,
-          editorRef.current.schemaTypes.block,
-          {
-            children: [{_key: 'c1', _type: 'span', marks: [], text: 'Block C'}],
-          },
-        )
-        const producedKey = PortableTextEditor.getValue(
-          editorRef.current,
-        )?.slice(-1)[0]?._key
-        PortableTextEditor.undo(editorRef.current)
-        PortableTextEditor.redo(editorRef.current)
-        expect(
-          PortableTextEditor.getValue(editorRef.current)?.slice(-1)[0]?._key,
-        ).toEqual(producedKey)
-      }
-    })
-  })
-})

package/src/internal-utils/__tests__/valueNormalization.test.tsx

@@ -1,79 +0,0 @@
-import {createTestKeyGenerator} from '@portabletext/test'
-import {render, waitFor} from '@testing-library/react'
-import {createRef, type RefObject} from 'react'
-import {describe, expect, it, vi} from 'vitest'
-import {PortableTextEditorTester} from '../../editor/__tests__/PortableTextEditorTester'
-import {PortableTextEditor} from '../../editor/PortableTextEditor'
-
-describe('values: normalization', () => {
-  it("accepts incoming value with blocks without a style or markDefs prop, but doesn't leave them without them when editing them", async () => {
-    const editorRef: RefObject<PortableTextEditor | null> = createRef()
-    const initialValue = [
-      {
-        _key: '5fc57af23597',
-        _type: 'block',
-        children: [
-          {
-            _key: 'be1c67c6971a',
-            _type: 'span',
-            marks: [],
-            text: 'Hello',
-          },
-        ],
-        markDefs: [],
-      },
-    ]
-    const onChange = vi.fn()
-    render(
-      <PortableTextEditorTester
-        keyGenerator={createTestKeyGenerator()}
-        onChange={onChange}
-        ref={editorRef}
-        value={initialValue}
-      />,
-    )
-
-    await waitFor(() => {
-      if (editorRef.current) {
-        expect(onChange).toHaveBeenCalledWith({
-          type: 'value',
-          value: initialValue,
-        })
-        expect(onChange).toHaveBeenCalledWith({type: 'ready'})
-      }
-    })
-
-    await waitFor(() => {
-      if (editorRef.current) {
-        PortableTextEditor.focus(editorRef.current)
-        PortableTextEditor.select(editorRef.current, {
-          focus: {
-            path: [{_key: '5fc57af23597'}, 'children', {_key: 'be1c67c6971a'}],
-            offset: 0,
-          },
-          anchor: {
-            path: [{_key: '5fc57af23597'}, 'children', {_key: 'be1c67c6971a'}],
-            offset: 5,
-          },
-        })
-        PortableTextEditor.toggleMark(editorRef.current, 'strong')
-        expect(PortableTextEditor.getValue(editorRef.current)).toEqual([
-          {
-            _key: '5fc57af23597',
-            _type: 'block',
-            children: [
-              {
-                _key: 'be1c67c6971a',
-                _type: 'span',
-                marks: ['strong'],
-                text: 'Hello',
-              },
-            ],
-            markDefs: [],
-            style: 'normal',
-          },
-        ])
-      }
-    })
-  })
-})

package/src/operations/behavior.operation.insert-inline-object.ts

@@ -1,59 +0,0 @@
-import {Editor, Transforms, type Element} from 'slate'
-import {parseInlineObject} from '../internal-utils/parse-blocks'
-import {toSlateValue} from '../internal-utils/values'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const insertInlineObjectOperationImplementation: BehaviorOperationImplementation<
-  'insert.inline object'
-> = ({context, operation}) => {
-  const parsedInlineObject = parseInlineObject({
-    context,
-    inlineObject: {
-      _type: operation.inlineObject.name,
-      ...(operation.inlineObject.value ?? {}),
-    },
-    options: {refreshKeys: false, validateFields: true},
-  })
-
-  if (!parsedInlineObject) {
-    throw new Error(
-      `Failed to parse inline object ${JSON.stringify(operation.inlineObject)}`,
-    )
-  }
-
-  if (!operation.editor.selection) {
-    console.error('Unable to insert inline object without selection')
-    return
-  }
-
-  const [focusTextBlock] = Array.from(
-    Editor.nodes(operation.editor, {
-      at: operation.editor.selection.focus.path,
-      match: (node) => operation.editor.isTextBlock(node),
-    }),
-  ).at(0) ?? [undefined, undefined]
-
-  if (!focusTextBlock) {
-    console.error('Unable to perform action without focus text block')
-    return
-  }
-
-  const block = toSlateValue(
-    [
-      {
-        _type: context.schema.block.name,
-        _key: context.keyGenerator(),
-        children: [parsedInlineObject],
-      },
-    ],
-    {schemaTypes: context.schema},
-  ).at(0) as unknown as Element
-  const child = block?.children.at(0)
-
-  if (!child) {
-    console.error('Unable to insert inline object')
-    return
-  }
-
-  Transforms.insertNodes(operation.editor, child)
-}

package/src/operations/behavior.operation.insert-span.ts

@@ -1,48 +0,0 @@
-import {Editor, Transforms} from 'slate'
-import type {BehaviorOperationImplementation} from './behavior.operations'
-
-export const insertSpanOperationImplementation: BehaviorOperationImplementation<
-  'insert.span'
-> = ({context, operation}) => {
-  if (!operation.editor.selection) {
-    console.error('Unable to perform action without selection', operation)
-    return
-  }
-
-  const [focusBlock, focusBlockPath] = Array.from(
-    Editor.nodes(operation.editor, {
-      at: operation.editor.selection.focus.path,
-      match: (node) => operation.editor.isTextBlock(node),
-    }),
-  )[0] ?? [undefined, undefined]
-
-  if (!focusBlock || !focusBlockPath) {
-    console.error('Unable to perform action without focus block', operation)
-    return
-  }
-
-  const markDefs = focusBlock.markDefs ?? []
-  const annotations = operation.annotations
-    ? operation.annotations.map((annotation) => ({
-        _type: annotation.name,
-        _key: context.keyGenerator(),
-        ...annotation.value,
-      }))
-    : undefined
-
-  if (annotations && annotations.length > 0) {
-    Transforms.setNodes(operation.editor, {
-      markDefs: [...markDefs, ...annotations],
-    })
-  }
-
-  Transforms.insertNodes(operation.editor, {
-    _type: 'span',
-    _key: context.keyGenerator(),
-    text: operation.text,
-    marks: [
-      ...(annotations?.map((annotation) => annotation._key) ?? []),
-      ...(operation.decorators ?? []),
-    ],
-  })
-}