@portabletext/editor 3.0.3 → 3.0.5

package/src/internal-utils/values.ts

@@ -24,17 +24,6 @@ function keepObjectEquality(
   return object
 }
 
-export function toSlateValue(
-  value: PortableTextBlock[] | undefined,
-  {schemaTypes}: {schemaTypes: EditorSchema},
-  keyMap: Record<string, any> = {},
-): Descendant[] {
-  if (value && Array.isArray(value)) {
-    return value.map((block) => toSlateBlock(block, {schemaTypes}, keyMap))
-  }
-  return []
-}
-
 export function toSlateBlock(
   block: PortableTextBlock,
   {schemaTypes}: {schemaTypes: EditorSchema},
@@ -141,51 +130,57 @@ export function fromSlateValue(
   textBlockType: string,
   keyMap: Record<string, PortableTextBlock | PortableTextChild> = {},
 ): PortableTextBlock[] {
-  return value.map((block) => {
-    const {_key, _type} = block
-    if (!_key || !_type) {
-      throw new Error('Not a valid block')
-    }
-    if (
-      _type === textBlockType &&
-      'children' in block &&
-      Array.isArray(block.children) &&
-      _key
-    ) {
-      let hasInlines = false
-      const children = block.children.map((child) => {
-        const {_type: _cType} = child
-        if ('value' in child && _cType !== 'span') {
-          hasInlines = true
-          const {
-            value: v,
-            _key: k,
-            _type: t,
-            __inline: _i,
-            children: _c,
-            ...rest
-          } = child
-          return keepObjectEquality(
-            {...rest, ...v, _key: k as string, _type: t as string},
-            keyMap,
-          )
-        }
-        return child
-      })
-      if (!hasInlines) {
-        return block as PortableTextBlock // Original object
+  return value.map((block) => fromSlateBlock(block, textBlockType, keyMap))
+}
+
+export function fromSlateBlock(
+  block: Descendant,
+  textBlockType: string,
+  keyMap: Record<string, PortableTextBlock | PortableTextChild> = {},
+) {
+  const {_key, _type} = block
+  if (!_key || !_type) {
+    throw new Error('Not a valid block')
+  }
+  if (
+    _type === textBlockType &&
+    'children' in block &&
+    Array.isArray(block.children) &&
+    _key
+  ) {
+    let hasInlines = false
+    const children = block.children.map((child) => {
+      const {_type: _cType} = child
+      if ('value' in child && _cType !== 'span') {
+        hasInlines = true
+        const {
+          value: v,
+          _key: k,
+          _type: t,
+          __inline: _i,
+          children: _c,
+          ...rest
+        } = child
+        return keepObjectEquality(
+          {...rest, ...v, _key: k as string, _type: t as string},
+          keyMap,
+        )
       }
-      return keepObjectEquality(
-        {...block, children, _key, _type},
-        keyMap,
-      ) as PortableTextBlock
+      return child
+    })
+    if (!hasInlines) {
+      return block as PortableTextBlock // Original object
     }
-    const blockValue = 'value' in block && block.value
     return keepObjectEquality(
-      {_key, _type, ...(typeof blockValue === 'object' ? blockValue : {})},
+      {...block, children, _key, _type},
       keyMap,
     ) as PortableTextBlock
-  })
+  }
+  const blockValue = 'value' in block && block.value
+  return keepObjectEquality(
+    {_key, _type, ...(typeof blockValue === 'object' ? blockValue : {})},
+    keyMap,
+  ) as PortableTextBlock
 }
 
 export function isEqualToEmptyEditor(

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

@@ -3,7 +3,7 @@ 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 {fromSlateValue} from '../internal-utils/values'
+import {fromSlateBlock} from '../internal-utils/values'
 import {parseBlock} from '../utils/parse-blocks'
 import type {BehaviorOperationImplementation} from './behavior.operations'
 
@@ -35,11 +35,11 @@ export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
     throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
   }
 
-  const parsedBlock = fromSlateValue(
-    [block],
+  const parsedBlock = fromSlateBlock(
+    block,
     context.schema.block.name,
     KEY_TO_VALUE_ELEMENT.get(operation.editor),
-  ).at(0)
+  )
 
   if (!parsedBlock) {
     throw new Error(`Unable to parse block at ${JSON.stringify(operation.at)}`)