@portabletext/editor 2.14.2 → 2.14.4

package/src/internal-utils/validateValue.ts

@@ -1,5 +1,5 @@
 import {insert, set, setIfMissing, unset} from '@portabletext/patches'
-import {isTextBlock} from '@portabletext/schema'
+import {isSpan, isTextBlock} from '@portabletext/schema'
 import type {
   PortableTextBlock,
   PortableTextSpan,
@@ -228,9 +228,9 @@ export function validateValue(
         const allUsedMarks = uniq(
           flatten(
             textBlock.children
-              .filter((cld) => cld._type === types.span.name)
+              .filter((child) => isSpan({schema: types}, child))
               .map((cld) => cld.marks || []),
-          ) as string[],
+          ),
         )
 
         // Test that all markDefs are in use (remove orphaned markDefs)

package/src/internal-utils/values.ts

@@ -30,82 +30,92 @@ export function toSlateValue(
   keyMap: Record<string, any> = {},
 ): Descendant[] {
   if (value && Array.isArray(value)) {
-    return value.map((block) => {
-      const {_type, _key, ...rest} = block
-      const isPortableText = block && block._type === schemaTypes.block.name
-      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'
+    return value.map((block) => toSlateBlock(block, {schemaTypes}, keyMap))
+  }
+  return []
+}
+
+export function toSlateBlock(
+  block: PortableTextBlock,
+  {schemaTypes}: {schemaTypes: EditorSchema},
+  keyMap: Record<string, any> = {},
+): Descendant {
+  const {_type, _key, ...rest} = block
+  const isPortableText = block && block._type === schemaTypes.block.name
+  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'
 
-        const children = (textBlock.children || []).map((child) => {
-          const {_type: cType, _key: cKey, ...cRest} = child
-          // Return 'slate' version of inline object where the actual
-          // value is stored in the `value` property.
-          // In slate, inline objects are represented as regular
-          // children with actual text node in order to be able to
-          // be selected the same way as the rest of the (text) content.
-          if (cType !== 'span') {
-            hasInlines = true
-            return keepObjectEquality(
+    const children = (textBlock.children || []).map((child) => {
+      const {_type: cType, _key: cKey, ...cRest} = child
+      // Return 'slate' version of inline object where the actual
+      // value is stored in the `value` property.
+      // In slate, inline objects are represented as regular
+      // children with actual text node in order to be able to
+      // be selected the same way as the rest of the (text) content.
+      if (cType !== 'span') {
+        hasInlines = true
+        return keepObjectEquality(
+          {
+            _type: cType,
+            _key: cKey,
+            children: [
               {
-                _type: cType,
-                _key: cKey,
-                children: [
-                  {
-                    _key: VOID_CHILD_KEY,
-                    _type: 'span',
-                    text: '',
-                    marks: [],
-                  },
-                ],
-                value: cRest,
-                __inline: true,
+                _key: VOID_CHILD_KEY,
+                _type: 'span',
+                text: '',
+                marks: [],
               },
-              keyMap,
-            )
-          }
-          // Original child object (span)
-          return child
-        })
-        // Return original block
-        if (
-          !hasMissingStyle &&
-          !hasMissingMarkDefs &&
-          !hasMissingChildren &&
-          !hasInlines &&
-          Element.isElement(block)
-        ) {
-          // Original object
-          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)
+            ],
+            value: cRest,
+            __inline: true,
+          },
+          keyMap,
+        )
       }
-      return keepObjectEquality(
+      // Original child object (span)
+      return child
+    })
+    // Return original block
+    if (
+      !hasMissingStyle &&
+      !hasMissingMarkDefs &&
+      !hasMissingChildren &&
+      !hasInlines &&
+      Element.isElement(block)
+    ) {
+      // Original object
+      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,
+    ) as Descendant
+  }
+
+  return keepObjectEquality(
+    {
+      _type,
+      _key,
+      children: [
         {
-          _type,
-          _key,
-          children: [
-            {
-              _key: VOID_CHILD_KEY,
-              _type: 'span',
-              text: '',
-              marks: [],
-            },
-          ],
-          value: rest,
+          _key: VOID_CHILD_KEY,
+          _type: 'span',
+          text: '',
+          marks: [],
         },
-        keyMap,
-      )
-    }) as Descendant[]
-  }
-  return []
+      ],
+      value: rest,
+    },
+    keyMap,
+  ) as Descendant
 }
 
 export function fromSlateValue(