@portabletext/editor 3.0.6 → 3.0.8

package/src/internal-utils/__tests__/values.test.ts

@@ -1,6 +1,6 @@
 import {compileSchema, defineSchema} from '@portabletext/schema'
 import {describe, expect, it} from 'vitest'
-import {fromSlateValue, toSlateBlock} from '../values'
+import {toSlateBlock} from '../values'
 
 const schemaTypes = compileSchema(defineSchema({}))
 
@@ -51,7 +51,6 @@ describe(toSlateBlock.name, () => {
           text: '123',
         },
       ],
-      style: 'normal',
     })
   })
 
@@ -106,125 +105,6 @@ describe(toSlateBlock.name, () => {
           },
         },
       ],
-      style: 'normal',
     })
   })
 })
-
-describe('fromSlateValue', () => {
-  it('runs given empty array', () => {
-    const result = fromSlateValue([], 'image')
-    expect(result).toHaveLength(0)
-  })
-
-  it('converts a slate value to portable text', () => {
-    const ptValue = fromSlateValue(
-      [
-        {
-          _type: 'block',
-          _key: 'dr239u3',
-          children: [
-            {
-              _type: 'span',
-              _key: '252f4swet',
-              marks: [],
-              text: 'Hey ',
-            },
-            {
-              _type: 'image',
-              _key: 'e324t4s',
-              __inline: true,
-              children: [{_key: '1', _type: 'span', text: '', marks: []}],
-              value: {
-                _type: 'image',
-                _key: 'e324t4s',
-                asset: {_ref: '32423r32rewr3rwerwer'},
-              },
-            },
-          ],
-          markDefs: [],
-          style: 'normal',
-        },
-        {
-          _type: 'image',
-          _key: 'wer32434',
-          children: [{_key: '1', _type: 'span', text: '', marks: []}],
-          value: {
-            _type: 'image',
-            _key: 'wer32434',
-            asset: {_ref: 'werwer452423423'},
-          },
-        },
-      ],
-      'block',
-    )
-    expect(ptValue).toEqual([
-      {
-        _type: 'block',
-        _key: 'dr239u3',
-        children: [
-          {
-            _type: 'span',
-            _key: '252f4swet',
-            marks: [],
-            text: 'Hey ',
-          },
-          {
-            _type: 'image',
-            _key: 'e324t4s',
-            asset: {_ref: '32423r32rewr3rwerwer'},
-          },
-        ],
-        markDefs: [],
-        style: 'normal',
-      },
-      {
-        _type: 'image',
-        _key: 'wer32434',
-        asset: {_ref: 'werwer452423423'},
-      },
-    ])
-  })
-
-  it('has equality', () => {
-    const keyMap = {}
-    const value = [
-      {
-        _type: 'image',
-        _key: 'wer32434',
-        asset: {_ref: 'werwer452423423'},
-      },
-      {
-        _type: 'block',
-        _key: 'dr239u3',
-        children: [
-          {
-            _type: 'span',
-            _key: '252f4swet',
-            marks: [],
-            text: 'Hey ',
-          },
-          {
-            _type: 'image',
-            _key: 'e324t4s',
-            asset: {_ref: '32423r32rewr3rwerwer'},
-          },
-        ],
-        markDefs: [],
-        style: 'normal',
-      },
-    ]
-    const toSlate1 = value.map((block) =>
-      toSlateBlock(block, {schemaTypes}, keyMap),
-    )
-    const toSlate2 = value.map((block) =>
-      toSlateBlock(block, {schemaTypes}, keyMap),
-    )
-    expect(toSlate1[0]).toBe(toSlate2[0])
-    expect(toSlate1[1]).toBe(toSlate2[1])
-    const fromSlate1 = fromSlateValue(toSlate1, 'block', keyMap)
-    const fromSlate2 = fromSlateValue(toSlate2, 'block', keyMap)
-    expect(fromSlate1[0]).toBe(fromSlate2[0])
-    expect(fromSlate1[1]).toBe(fromSlate2[1])
-  })
-})

package/src/internal-utils/applyPatch.ts

@@ -145,7 +145,7 @@ function insertPatch(
     const normalizedIdx =
       position === 'after' ? targetBlockIndex + 1 : targetBlockIndex
 
-    const editorWasEmptyBefore = isEqualToEmptyEditor(editor.children, schema)
+    const editorWasEmptyBefore = isEqualToEmptyEditor(editor.value, schema)
 
     Transforms.insertNodes(editor, blocksToInsert, {at: [normalizedIdx]})
 

package/src/internal-utils/operation-to-patches.test.ts

@@ -1,5 +1,9 @@
 import {compileSchemaDefinitionToPortableTextMemberSchemaTypes} from '@portabletext/sanity-bridge'
-import {compileSchema, defineSchema} from '@portabletext/schema'
+import {
+  compileSchema,
+  defineSchema,
+  type PortableTextBlock,
+} from '@portabletext/schema'
 import type {PortableTextTextBlock} from '@sanity/types'
 import {createEditor, type Descendant} from 'slate'
 import {beforeEach, describe, expect, it, test} from 'vitest'
@@ -32,13 +36,15 @@ const editorActor = createActor(editorMachine, {
 })
 const relayActor = createActor(relayMachine)
 
-const editor = withPlugins(createEditor(), {
+const e = createEditor()
+e.value = []
+const editor = withPlugins(e, {
   editorActor,
   relayActor,
   subscriptions: [],
 })
 
-const createDefaultValue = () =>
+const createDefaultChildren = () =>
   [
     {
       _type: 'block',
@@ -57,7 +63,25 @@ const createDefaultValue = () =>
         {_type: 'span', _key: 'fd9b4a4e6c0b', text: '', marks: []},
       ],
     },
-  ] as Descendant[]
+  ] satisfies Array<Descendant>
+const createDefaultValue = () =>
+  [
+    {
+      _type: 'block',
+      _key: '1f2e64b47787',
+      style: 'normal',
+      markDefs: [],
+      children: [
+        {_type: 'span', _key: 'c130395c640c', text: '', marks: []},
+        {
+          _key: '773866318fa8',
+          _type: 'someObject',
+          value: {title: 'The Object'},
+        },
+        {_type: 'span', _key: 'fd9b4a4e6c0b', text: '', marks: []},
+      ],
+    },
+  ] as Array<PortableTextBlock>
 
 describe(insertNodePatch.name, () => {
   test('Scenario: Inserting block object on empty editor', () => {
@@ -121,7 +145,7 @@ describe(insertNodePatch.name, () => {
 
 describe('operationToPatches', () => {
   beforeEach(() => {
-    editor.children = createDefaultValue()
+    editor.children = createDefaultChildren()
     editor.onChange()
   })
 
@@ -418,12 +442,13 @@ describe('operationToPatches', () => {
   })
 
   it('produce correct remove block patch', () => {
+    const children = createDefaultChildren()
     const val = createDefaultValue()
     expect(
       removeNodePatch(editorActor.getSnapshot().context.schema, val, {
         type: 'remove_node',
         path: [0],
-        node: val[0],
+        node: children[0],
       }),
     ).toMatchInlineSnapshot(`
       [

package/src/internal-utils/operation-to-patches.ts

@@ -7,7 +7,7 @@ import {
   type InsertPosition,
   type Patch,
 } from '@portabletext/patches'
-import {isSpan, isTextBlock} from '@portabletext/schema'
+import {isSpan, isTextBlock, type PortableTextBlock} from '@portabletext/schema'
 import type {Path, PortableTextSpan, PortableTextTextBlock} from '@sanity/types'
 import {
   Element,
@@ -29,7 +29,7 @@ export function insertTextPatch(
   schema: EditorSchema,
   children: Descendant[],
   operation: InsertTextOperation,
-  beforeValue: Descendant[],
+  beforeValue: Array<PortableTextBlock>,
 ): Array<Patch> {
   const block =
     isTextBlock({schema}, children[operation.path[0]]) &&
@@ -62,7 +62,7 @@ export function removeTextPatch(
   schema: EditorSchema,
   children: Descendant[],
   operation: RemoveTextOperation,
-  beforeValue: Descendant[],
+  beforeValue: Array<PortableTextBlock>,
 ): Array<Patch> {
   const block = children[operation.path[0]]
   if (!block) {
@@ -271,7 +271,7 @@ export function insertNodePatch(
   schema: EditorSchema,
   children: Descendant[],
   operation: InsertNodeOperation,
-  beforeValue: Descendant[],
+  beforeValue: Array<PortableTextBlock>,
 ): Array<Patch> {
   const block = beforeValue[operation.path[0]]
   if (operation.path.length === 1) {
@@ -346,7 +346,7 @@ export function splitNodePatch(
   schema: EditorSchema,
   children: Descendant[],
   operation: SplitNodeOperation,
-  beforeValue: Descendant[],
+  beforeValue: Array<PortableTextBlock>,
 ): Array<Patch> {
   const patches: Patch[] = []
   const splitBlock = children[operation.path[0]]
@@ -414,7 +414,7 @@ export function splitNodePatch(
 
 export function removeNodePatch(
   schema: EditorSchema,
-  beforeValue: Descendant[],
+  beforeValue: Array<PortableTextBlock>,
   operation: RemoveNodeOperation,
 ): Array<Patch> {
   const block = beforeValue[operation.path[0]]
@@ -454,7 +454,7 @@ export function mergeNodePatch(
   schema: EditorSchema,
   children: Descendant[],
   operation: MergeNodeOperation,
-  beforeValue: Descendant[],
+  beforeValue: Array<PortableTextBlock>,
 ): Array<Patch> {
   const patches: Patch[] = []
 
@@ -532,7 +532,7 @@ export function mergeNodePatch(
 
 export function moveNodePatch(
   schema: EditorSchema,
-  beforeValue: Descendant[],
+  beforeValue: Array<PortableTextBlock>,
   operation: MoveNodeOperation,
 ): Array<Patch> {
   const patches: Patch[] = []
@@ -547,11 +547,7 @@ export function moveNodePatch(
     const position: InsertPosition =
       operation.path[0] > operation.newPath[0] ? 'before' : 'after'
     patches.push(unset([{_key: block._key}]))
-    patches.push(
-      insert([fromSlateBlock(block, schema.block.name)], position, [
-        {_key: targetBlock._key},
-      ]),
-    )
+    patches.push(insert([block], position, [{_key: targetBlock._key}]))
   } else if (
     operation.path.length === 2 &&
     isTextBlock({schema}, block) &&
@@ -561,9 +557,7 @@ export function moveNodePatch(
     const targetChild = targetBlock.children[operation.newPath[1]]
     const position =
       operation.newPath[1] === targetBlock.children.length ? 'after' : 'before'
-    const childToInsert = (
-      fromSlateBlock(block, schema.block.name) as PortableTextTextBlock
-    ).children[operation.path[1]]
+    const childToInsert = block.children[operation.path[1]]
     patches.push(unset([{_key: block._key}, 'children', {_key: child._key}]))
     patches.push(
       insert([childToInsert], position, [

package/src/internal-utils/values.test.ts

@@ -32,7 +32,6 @@ describe(toSlateBlock.name, () => {
               text: 'foo',
             },
           ],
-          style: 'normal',
         })
       })
 
@@ -62,7 +61,6 @@ describe(toSlateBlock.name, () => {
               text: 'foo',
             },
           ],
-          style: 'normal',
         })
       })
 
@@ -101,7 +99,6 @@ describe(toSlateBlock.name, () => {
               __inline: true,
             },
           ],
-          style: 'normal',
         })
       })
     })
@@ -148,7 +145,6 @@ describe(toSlateBlock.name, () => {
               },
             },
           ],
-          style: 'normal',
         })
       })
 
@@ -191,7 +187,6 @@ describe(toSlateBlock.name, () => {
               },
             },
           ],
-          style: 'normal',
         })
       })
     })
@@ -238,7 +233,6 @@ describe(toSlateBlock.name, () => {
               },
             },
           ],
-          style: 'normal',
         })
       })
 
@@ -281,7 +275,6 @@ describe(toSlateBlock.name, () => {
               },
             },
           ],
-          style: 'normal',
         })
       })
     })

package/src/internal-utils/values.ts

@@ -35,7 +35,6 @@ export function toSlateBlock(
   if (isPortableText) {
     const textBlock = block as PortableTextTextBlock
     let hasInlines = false
-    const hasMissingStyle = typeof textBlock.style === 'undefined'
     const hasMissingMarkDefs = typeof textBlock.markDefs === 'undefined'
     const hasMissingChildren = typeof textBlock.children === 'undefined'
 
@@ -86,7 +85,6 @@ export function toSlateBlock(
 
     // Return original block
     if (
-      !hasMissingStyle &&
       !hasMissingMarkDefs &&
       !hasMissingChildren &&
       !hasInlines &&
@@ -96,11 +94,6 @@ export function toSlateBlock(
       return block
     }
 
-    // TODO: remove this when we have a better way to handle missing style
-    if (hasMissingStyle) {
-      rest.style = schemaTypes.styles[0].name
-    }
-
     return keepObjectEquality(
       {_type, _key, ...rest, children},
       keyMap,
@@ -125,14 +118,6 @@ export function toSlateBlock(
   ) as Descendant
 }
 
-export function fromSlateValue(
-  value: Descendant[],
-  textBlockType: string,
-  keyMap: Record<string, PortableTextBlock | PortableTextChild> = {},
-): PortableTextBlock[] {
-  return value.map((block) => fromSlateBlock(block, textBlockType, keyMap))
-}
-
 export function fromSlateBlock(
   block: Descendant,
   textBlockType: string,
@@ -184,25 +169,76 @@ export function fromSlateBlock(
 }
 
 export function isEqualToEmptyEditor(
-  children: Descendant[] | PortableTextBlock[],
+  blocks: Array<Descendant> | Array<PortableTextBlock>,
   schemaTypes: EditorSchema,
 ): boolean {
-  return (
-    children === undefined ||
-    (children && Array.isArray(children) && children.length === 0) ||
-    (children &&
-      Array.isArray(children) &&
-      children.length === 1 &&
-      Element.isElement(children[0]) &&
-      children[0]._type === schemaTypes.block.name &&
-      'style' in children[0] &&
-      children[0].style === schemaTypes.styles[0].name &&
-      !('listItem' in children[0]) &&
-      Array.isArray(children[0].children) &&
-      children[0].children.length === 1 &&
-      Text.isText(children[0].children[0]) &&
-      children[0].children[0]._type === 'span' &&
-      !children[0].children[0].marks?.join('') &&
-      children[0].children[0].text === '')
-  )
+  // Must have exactly one block
+  if (blocks.length !== 1) {
+    return false
+  }
+
+  const firstBlock = blocks.at(0)
+
+  if (!firstBlock) {
+    return true
+  }
+
+  if (!Element.isElement(firstBlock)) {
+    return false
+  }
+
+  // Must be a text block
+  if (firstBlock._type !== schemaTypes.block.name) {
+    return false
+  }
+
+  // Must not be a list item
+  if ('listItem' in firstBlock) {
+    return false
+  }
+
+  // Style must exist and be the default style
+  if (
+    !('style' in firstBlock) ||
+    firstBlock.style !== schemaTypes.styles.at(0)?.name
+  ) {
+    return false
+  }
+
+  // Must have children array
+  if (!Array.isArray(firstBlock.children)) {
+    return false
+  }
+
+  // Must have exactly one child
+  if (firstBlock.children.length !== 1) {
+    return false
+  }
+
+  const firstChild = firstBlock.children.at(0)
+
+  if (!firstChild) {
+    return false
+  }
+
+  if (!Text.isText(firstChild)) {
+    return false
+  }
+
+  // Must be a span type
+  if (!('_type' in firstChild) || firstChild._type !== schemaTypes.span.name) {
+    return false
+  }
+
+  // Must have empty text
+  if (firstChild.text !== '') {
+    return false
+  }
+
+  // Must have no marks (marks can be undefined or empty array)
+  if (firstChild.marks?.join('')) {
+    return false
+  }
+
+  return true
 }

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

@@ -1,56 +1,32 @@
 import {isTextBlock} from '@portabletext/schema'
 import {omit} from 'lodash'
-import {Editor, Transforms} from 'slate'
-import {KEY_TO_VALUE_ELEMENT} from '../editor/weakMaps'
-import {toSlateRange} from '../internal-utils/to-slate-range'
-import {fromSlateBlock} from '../internal-utils/values'
+import {Transforms} from 'slate'
 import {parseBlock} from '../utils/parse-blocks'
 import type {BehaviorOperationImplementation} from './behavior.operations'
 
 export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
   'block.unset'
 > = ({context, operation}) => {
-  const location = toSlateRange({
-    context: {
-      schema: context.schema,
-      value: operation.editor.value,
-      selection: {
-        anchor: {path: operation.at, offset: 0},
-        focus: {path: operation.at, offset: 0},
-      },
-    },
-    blockIndexMap: operation.editor.blockIndexMap,
-  })
+  const blockKey = operation.at[0]._key
+  const blockIndex = operation.editor.blockIndexMap.get(blockKey)
 
-  if (!location) {
-    throw new Error(
-      `Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`,
-    )
+  if (blockIndex === undefined) {
+    throw new Error(`Unable to find block index for block key ${blockKey}`)
   }
 
-  const blockEntry = Editor.node(operation.editor, location, {depth: 1})
-  const block = blockEntry?.[0]
+  const block =
+    blockIndex !== undefined ? operation.editor.value.at(blockIndex) : undefined
 
   if (!block) {
     throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
   }
 
-  const parsedBlock = fromSlateBlock(
-    block,
-    context.schema.block.name,
-    KEY_TO_VALUE_ELEMENT.get(operation.editor),
-  )
-
-  if (!parsedBlock) {
-    throw new Error(`Unable to parse block at ${JSON.stringify(operation.at)}`)
-  }
-
-  if (isTextBlock(context, parsedBlock)) {
+  if (isTextBlock(context, block)) {
     const propsToRemove = operation.props.filter((prop) => prop !== '_type')
 
     const updatedTextBlock = parseBlock({
       context,
-      block: omit(parsedBlock, propsToRemove),
+      block: omit(block, propsToRemove),
       options: {
         normalize: false,
         removeUnusedMarkDefs: true,
@@ -74,7 +50,7 @@ export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
       }
     }
 
-    Transforms.setNodes(operation.editor, propsToSet, {at: location})
+    Transforms.setNodes(operation.editor, propsToSet, {at: [blockIndex]})
 
     return
   }
@@ -82,7 +58,7 @@ export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
   const updatedBlockObject = parseBlock({
     context,
     block: omit(
-      parsedBlock,
+      block,
       operation.props.filter((prop) => prop !== '_type'),
     ),
     options: {
@@ -105,6 +81,6 @@ export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
       _key,
       value: props,
     },
-    {at: location},
+    {at: [blockIndex]},
   )
 }

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

@@ -1,30 +1,48 @@
 import {applyAll} from '@portabletext/patches'
+import {isTextBlock} from '@portabletext/schema'
 import {Editor, Element, Transforms} from 'slate'
-import {toSlateRange} from '../internal-utils/to-slate-range'
 import type {BehaviorOperationImplementation} from './behavior.operations'
 
 export const childUnsetOperationImplementation: BehaviorOperationImplementation<
   'child.unset'
 > = ({context, operation}) => {
-  const location = toSlateRange({
-    context: {
-      schema: context.schema,
-      value: operation.editor.value,
-      selection: {
-        anchor: {path: operation.at, offset: 0},
-        focus: {path: operation.at, offset: 0},
-      },
-    },
-    blockIndexMap: operation.editor.blockIndexMap,
-  })
+  const blockKey = operation.at[0]._key
+  const blockIndex = operation.editor.blockIndexMap.get(blockKey)
+
+  if (blockIndex === undefined) {
+    throw new Error(`Unable to find block index for block key ${blockKey}`)
+  }
+
+  const block =
+    blockIndex !== undefined ? operation.editor.value.at(blockIndex) : undefined
+
+  if (!block) {
+    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
+  }
+
+  if (!isTextBlock(context, block)) {
+    throw new Error(`Block ${JSON.stringify(blockKey)} is not a text block`)
+  }
+
+  const childKey = operation.at[2]._key
 
-  if (!location) {
+  if (!childKey) {
     throw new Error(
-      `Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`,
+      `Unable to find child key at ${JSON.stringify(operation.at)}`,
     )
   }
 
-  const childEntry = Editor.node(operation.editor, location, {depth: 2})
+  const childIndex = block.children.findIndex(
+    (child) => child._key === childKey,
+  )
+
+  if (childIndex === -1) {
+    throw new Error(`Unable to find child at ${JSON.stringify(operation.at)}`)
+  }
+
+  const childEntry = Editor.node(operation.editor, [blockIndex, childIndex], {
+    depth: 2,
+  })
   const child = childEntry?.[0]
   const childPath = childEntry?.[1]