@portabletext/editor 3.0.2 → 3.0.4

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

@@ -0,0 +1,289 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
+import {createTestKeyGenerator} from '@portabletext/test'
+import {describe, expect, test} from 'vitest'
+import {toSlateBlock, VOID_CHILD_KEY} from './values'
+
+describe(toSlateBlock.name, () => {
+  describe('text block', () => {
+    describe('with span', () => {
+      test('with _type', () => {
+        const keyGenerator = createTestKeyGenerator()
+        const blockKey = keyGenerator()
+        const spanKey = keyGenerator()
+
+        expect(
+          toSlateBlock(
+            {
+              _type: 'block',
+              _key: blockKey,
+              children: [{_key: spanKey, _type: 'span', text: 'foo'}],
+            },
+            {
+              schemaTypes: compileSchema(defineSchema({})),
+            },
+          ),
+        ).toEqual({
+          _type: 'block',
+          _key: blockKey,
+          children: [
+            {
+              _key: spanKey,
+              _type: 'span',
+              text: 'foo',
+            },
+          ],
+          style: 'normal',
+        })
+      })
+
+      test('without _type', () => {
+        const keyGenerator = createTestKeyGenerator()
+        const blockKey = keyGenerator()
+        const spanKey = keyGenerator()
+
+        expect(
+          toSlateBlock(
+            {
+              _type: 'block',
+              _key: blockKey,
+              children: [{_key: spanKey, text: 'foo'}],
+            },
+            {
+              schemaTypes: compileSchema(defineSchema({})),
+            },
+          ),
+        ).toEqual({
+          _type: 'block',
+          _key: blockKey,
+          children: [
+            {
+              _key: spanKey,
+              _type: 'span',
+              text: 'foo',
+            },
+          ],
+          style: 'normal',
+        })
+      })
+
+      test('wrong _type', () => {
+        const keyGenerator = createTestKeyGenerator()
+        const blockKey = keyGenerator()
+        const spanKey = keyGenerator()
+
+        expect(
+          toSlateBlock(
+            {
+              _type: 'block',
+              _key: blockKey,
+              children: [{_key: spanKey, _type: 'stock-ticker', text: 'foo'}],
+            },
+            {
+              schemaTypes: compileSchema(defineSchema({})),
+            },
+          ),
+        ).toEqual({
+          _type: 'block',
+          _key: blockKey,
+          children: [
+            {
+              _key: spanKey,
+              _type: 'stock-ticker',
+              children: [
+                {
+                  _key: VOID_CHILD_KEY,
+                  _type: 'span',
+                  text: '',
+                  marks: [],
+                },
+              ],
+              value: {text: 'foo'},
+              __inline: true,
+            },
+          ],
+          style: 'normal',
+        })
+      })
+    })
+
+    describe('with inline object', () => {
+      test('known inline object _type', () => {
+        const keyGenerator = createTestKeyGenerator()
+        const blockKey = keyGenerator()
+        const stockTickerKey = keyGenerator()
+
+        expect(
+          toSlateBlock(
+            {
+              _type: 'block',
+              _key: blockKey,
+              children: [
+                {_type: 'stock-ticker', _key: stockTickerKey, symbol: 'AAPL'},
+              ],
+            },
+            {
+              schemaTypes: compileSchema(
+                defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+              ),
+            },
+          ),
+        ).toEqual({
+          _type: 'block',
+          _key: blockKey,
+          children: [
+            {
+              __inline: true,
+              _key: stockTickerKey,
+              _type: 'stock-ticker',
+              children: [
+                {
+                  _key: VOID_CHILD_KEY,
+                  _type: 'span',
+                  text: '',
+                  marks: [],
+                },
+              ],
+              value: {
+                symbol: 'AAPL',
+              },
+            },
+          ],
+          style: 'normal',
+        })
+      })
+
+      test('unknown inline object _type', () => {
+        const keyGenerator = createTestKeyGenerator()
+        const blockKey = keyGenerator()
+        const stockTickerKey = keyGenerator()
+
+        expect(
+          toSlateBlock(
+            {
+              _type: 'block',
+              _key: blockKey,
+              children: [
+                {_type: 'stock-ticker', _key: stockTickerKey, symbol: 'AAPL'},
+              ],
+            },
+            {
+              schemaTypes: compileSchema(defineSchema({})),
+            },
+          ),
+        ).toEqual({
+          _type: 'block',
+          _key: blockKey,
+          children: [
+            {
+              __inline: true,
+              _key: stockTickerKey,
+              _type: 'stock-ticker',
+              children: [
+                {
+                  _key: VOID_CHILD_KEY,
+                  _type: 'span',
+                  text: '',
+                  marks: [],
+                },
+              ],
+              value: {
+                symbol: 'AAPL',
+              },
+            },
+          ],
+          style: 'normal',
+        })
+      })
+    })
+
+    describe('with inline object with text prop', () => {
+      test('known inline object _type', () => {
+        const keyGenerator = createTestKeyGenerator()
+        const blockKey = keyGenerator()
+        const stockTickerKey = keyGenerator()
+
+        expect(
+          toSlateBlock(
+            {
+              _type: 'block',
+              _key: blockKey,
+              children: [
+                {_type: 'stock-ticker', _key: stockTickerKey, text: 'foo'},
+              ],
+            },
+            {
+              schemaTypes: compileSchema(
+                defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+              ),
+            },
+          ),
+        ).toEqual({
+          _type: 'block',
+          _key: blockKey,
+          children: [
+            {
+              __inline: true,
+              _key: stockTickerKey,
+              _type: 'stock-ticker',
+              children: [
+                {
+                  _key: VOID_CHILD_KEY,
+                  _type: 'span',
+                  text: '',
+                  marks: [],
+                },
+              ],
+              value: {
+                text: 'foo',
+              },
+            },
+          ],
+          style: 'normal',
+        })
+      })
+
+      test('unknown inline object _type', () => {
+        const keyGenerator = createTestKeyGenerator()
+        const blockKey = keyGenerator()
+        const stockTickerKey = keyGenerator()
+
+        expect(
+          toSlateBlock(
+            {
+              _type: 'block',
+              _key: blockKey,
+              children: [
+                {_type: 'stock-ticker', _key: stockTickerKey, text: 'foo'},
+              ],
+            },
+            {
+              schemaTypes: compileSchema(defineSchema({})),
+            },
+          ),
+        ).toEqual({
+          _type: 'block',
+          _key: blockKey,
+          children: [
+            {
+              __inline: true,
+              _key: stockTickerKey,
+              _type: 'stock-ticker',
+              children: [
+                {
+                  _key: VOID_CHILD_KEY,
+                  _type: 'span',
+                  text: '',
+                  marks: [],
+                },
+              ],
+              value: {
+                text: 'foo',
+              },
+            },
+          ],
+          style: 'normal',
+        })
+      })
+    })
+  })
+})

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},
@@ -54,11 +43,17 @@ export function toSlateBlock(
       const {_type: childType, _key: childKey, ...childProps} = child
       const propKeys = Object.keys(childProps)
 
-      if (childType !== schemaTypes.span.name) {
+      if (childType === undefined) {
         if (propKeys.length === 1 && propKeys.at(0) === 'text') {
-          return child
+          return {
+            _key: childKey,
+            _type: schemaTypes.span.name,
+            text: childProps.text,
+          }
         }
+      }
 
+      if (childType !== schemaTypes.span.name) {
         // Return 'slate' version of inline object where the actual
         // value is stored in the `value` property.
         // In slate, inline objects are represented as regular
@@ -135,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)}`)