@portabletext/editor 3.0.0 → 3.0.2

package/src/utils/parse-blocks.test.ts

@@ -1,7 +1,12 @@
 import {compileSchema, defineSchema} from '@portabletext/schema'
 import {createTestKeyGenerator} from '@portabletext/test'
 import {describe, expect, test} from 'vitest'
-import {parseBlock, parseSpan} from './parse-blocks'
+import {
+  parseBlock,
+  parseChild,
+  parseInlineObject,
+  parseSpan,
+} from './parse-blocks'
 
 describe(parseBlock.name, () => {
   test('null', () => {
@@ -12,7 +17,11 @@ describe(parseBlock.name, () => {
           keyGenerator: createTestKeyGenerator(),
           schema: compileSchema(defineSchema({})),
         },
-        options: {removeUnusedMarkDefs: true, validateFields: true},
+        options: {
+          normalize: false,
+          removeUnusedMarkDefs: true,
+          validateFields: true,
+        },
       }),
     ).toBe(undefined)
   })
@@ -25,7 +34,11 @@ describe(parseBlock.name, () => {
           keyGenerator: createTestKeyGenerator(),
           schema: compileSchema(defineSchema({})),
         },
-        options: {removeUnusedMarkDefs: true, validateFields: true},
+        options: {
+          normalize: false,
+          removeUnusedMarkDefs: true,
+          validateFields: true,
+        },
       }),
     ).toBe(undefined)
   })
@@ -39,7 +52,11 @@ describe(parseBlock.name, () => {
             keyGenerator: createTestKeyGenerator(),
             schema: compileSchema(defineSchema({})),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toBe(undefined)
     })
@@ -54,7 +71,11 @@ describe(parseBlock.name, () => {
               defineSchema({blockObjects: [{name: 'image'}]}),
             ),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toBe(undefined)
     })
@@ -69,7 +90,11 @@ describe(parseBlock.name, () => {
               defineSchema({blockObjects: [{name: 'image'}]}),
             ),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toEqual({
         _key: 'k0',
@@ -87,7 +112,11 @@ describe(parseBlock.name, () => {
             keyGenerator: createTestKeyGenerator(),
             schema: compileSchema(defineSchema({})),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toEqual({
         _key: 'k0',
@@ -114,7 +143,11 @@ describe(parseBlock.name, () => {
             keyGenerator: createTestKeyGenerator(),
             schema: {...schema, block: {...schema.block, name: 'text'}},
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toEqual({
         _key: 'k0',
@@ -149,7 +182,11 @@ describe(parseBlock.name, () => {
             keyGenerator: createTestKeyGenerator(),
             schema: compileSchema(defineSchema({})),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toBe(undefined)
     })
@@ -166,7 +203,7 @@ describe(parseBlock.name, () => {
               42,
               {foo: 'bar'},
               {
-                _key: 'k1',
+                _key: 'some key',
                 text: 'foo',
                 marks: [],
               },
@@ -177,6 +214,7 @@ describe(parseBlock.name, () => {
               {_type: 'span', text: 'foo'},
               {_type: 'span', marks: ['strong']},
               {_type: 'span', marks: ['em']},
+              {_type: 'image', text: 'inline object or span?'},
             ],
           },
           context: {
@@ -188,12 +226,22 @@ describe(parseBlock.name, () => {
               }),
             ),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toEqual({
         _key: 'k0',
         _type: 'block',
         children: [
+          {
+            _key: 'some key',
+            _type: 'span',
+            text: 'foo',
+            marks: [],
+          },
           {
             _key: 'k1',
             _type: 'stock-ticker',
@@ -236,7 +284,11 @@ describe(parseBlock.name, () => {
             keyGenerator: createTestKeyGenerator(),
             schema: compileSchema(defineSchema({lists: [{name: 'bullet'}]})),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toEqual({
         _key: 'k0',
@@ -263,7 +315,11 @@ describe(parseBlock.name, () => {
             keyGenerator: createTestKeyGenerator(),
             schema: compileSchema(defineSchema({lists: [{name: 'bullet'}]})),
           },
-          options: {removeUnusedMarkDefs: true, validateFields: true},
+          options: {
+            normalize: false,
+            removeUnusedMarkDefs: true,
+            validateFields: true,
+          },
         }),
       ).toEqual({
         _key: 'k0',
@@ -290,7 +346,11 @@ describe(parseBlock.name, () => {
               keyGenerator: createTestKeyGenerator(),
               schema: compileSchema(defineSchema({})),
             },
-            options: {removeUnusedMarkDefs: true, validateFields: true},
+            options: {
+              normalize: false,
+              removeUnusedMarkDefs: true,
+              validateFields: true,
+            },
           }),
         ).toEqual({
           _type: 'block',
@@ -320,7 +380,11 @@ describe(parseBlock.name, () => {
                 }),
               ),
             },
-            options: {removeUnusedMarkDefs: true, validateFields: true},
+            options: {
+              normalize: false,
+              removeUnusedMarkDefs: true,
+              validateFields: true,
+            },
           }),
         ).toEqual({
           _type: 'block',
@@ -351,7 +415,11 @@ describe(parseBlock.name, () => {
                 }),
               ),
             },
-            options: {removeUnusedMarkDefs: true, validateFields: true},
+            options: {
+              normalize: false,
+              removeUnusedMarkDefs: true,
+              validateFields: true,
+            },
           }),
         ).toEqual({
           _type: 'block',
@@ -533,3 +601,252 @@ describe(parseSpan.name, () => {
     })
   })
 })
+
+describe(parseInlineObject.name, () => {
+  test('undefined', () => {
+    expect(
+      parseInlineObject({
+        inlineObject: undefined,
+        context: {
+          keyGenerator: createTestKeyGenerator(),
+          schema: compileSchema(
+            defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+          ),
+        },
+        options: {validateFields: true},
+      }),
+    ).toBe(undefined)
+  })
+
+  test('null', () => {
+    expect(
+      parseInlineObject({
+        inlineObject: null,
+        context: {
+          keyGenerator: createTestKeyGenerator(),
+          schema: compileSchema(
+            defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+          ),
+        },
+        options: {validateFields: true},
+      }),
+    ).toBe(undefined)
+  })
+
+  test('empty object', () => {
+    expect(
+      parseInlineObject({
+        inlineObject: {},
+        context: {
+          keyGenerator: createTestKeyGenerator(),
+          schema: compileSchema(
+            defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+          ),
+        },
+        options: {validateFields: true},
+      }),
+    ).toBe(undefined)
+  })
+
+  test('invalid _type', () => {
+    expect(
+      parseInlineObject({
+        inlineObject: {_type: 'image'},
+        context: {
+          keyGenerator: createTestKeyGenerator(),
+          schema: compileSchema(
+            defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+          ),
+        },
+        options: {validateFields: true},
+      }),
+    ).toBe(undefined)
+  })
+
+  test('only _type', () => {
+    expect(
+      parseInlineObject({
+        inlineObject: {_type: 'stock-ticker'},
+        context: {
+          keyGenerator: createTestKeyGenerator(),
+          schema: compileSchema(
+            defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+          ),
+        },
+        options: {validateFields: true},
+      }),
+    ).toEqual({
+      _key: 'k0',
+      _type: 'stock-ticker',
+    })
+  })
+
+  describe('looks like text node', () => {
+    test('known inline object _type', () => {
+      expect(
+        parseInlineObject({
+          inlineObject: {_type: 'stock-ticker', text: 'foo'},
+          context: {
+            keyGenerator: createTestKeyGenerator(),
+            schema: compileSchema(
+              defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+            ),
+          },
+          options: {validateFields: true},
+        }),
+      ).toEqual({_key: 'k0', _type: 'stock-ticker'})
+    })
+
+    test('unknown inline object _type', () => {
+      expect(
+        parseInlineObject({
+          inlineObject: {_type: 'image', text: 'foo'},
+          context: {
+            keyGenerator: createTestKeyGenerator(),
+            schema: compileSchema(
+              defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+            ),
+          },
+          options: {validateFields: true},
+        }),
+      ).toBe(undefined)
+    })
+  })
+
+  describe('custom props', () => {
+    describe('unknown prop', () => {
+      test('validateFields: true', () => {
+        expect(
+          parseInlineObject({
+            inlineObject: {_type: 'stock-ticker', foo: 'bar'},
+            context: {
+              keyGenerator: createTestKeyGenerator(),
+              schema: compileSchema(
+                defineSchema({
+                  inlineObjects: [{name: 'stock-ticker'}],
+                }),
+              ),
+            },
+            options: {validateFields: true},
+          }),
+        ).toEqual({
+          _key: 'k0',
+          _type: 'stock-ticker',
+        })
+      })
+
+      test('validateFields: false', () => {
+        expect(
+          parseInlineObject({
+            inlineObject: {_type: 'stock-ticker', foo: 'bar'},
+            context: {
+              keyGenerator: createTestKeyGenerator(),
+              schema: compileSchema(
+                defineSchema({
+                  inlineObjects: [{name: 'stock-ticker'}],
+                }),
+              ),
+            },
+            options: {validateFields: false},
+          }),
+        ).toEqual({
+          _key: 'k0',
+          _type: 'stock-ticker',
+          foo: 'bar',
+        })
+      })
+    })
+
+    describe('known prop', () => {
+      test('validateFields: true', () => {
+        expect(
+          parseInlineObject({
+            inlineObject: {_type: 'stock-ticker', foo: 'bar'},
+            context: {
+              keyGenerator: createTestKeyGenerator(),
+              schema: compileSchema(
+                defineSchema({
+                  inlineObjects: [
+                    {
+                      name: 'stock-ticker',
+                      fields: [{name: 'foo', type: 'string'}],
+                    },
+                  ],
+                }),
+              ),
+            },
+            options: {validateFields: true},
+          }),
+        ).toEqual({
+          _key: 'k0',
+          _type: 'stock-ticker',
+          foo: 'bar',
+        })
+      })
+    })
+
+    test('validateFields: false', () => {
+      expect(
+        parseInlineObject({
+          inlineObject: {_type: 'stock-ticker', foo: 'bar'},
+          context: {
+            keyGenerator: createTestKeyGenerator(),
+            schema: compileSchema(
+              defineSchema({
+                inlineObjects: [
+                  {
+                    name: 'stock-ticker',
+                    fields: [{name: 'foo', type: 'string'}],
+                  },
+                ],
+              }),
+            ),
+          },
+          options: {validateFields: false},
+        }),
+      ).toEqual({
+        _key: 'k0',
+        _type: 'stock-ticker',
+        foo: 'bar',
+      })
+    })
+  })
+})
+
+describe(parseChild.name, () => {
+  describe('inline object', () => {
+    describe('looks like text node', () => {
+      test('known inline object _type', () => {
+        expect(
+          parseChild({
+            context: {
+              keyGenerator: createTestKeyGenerator(),
+              schema: compileSchema(
+                defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+              ),
+            },
+            markDefKeyMap: new Map(),
+            options: {validateFields: true},
+            child: {_type: 'stock-ticker', text: 'foo'},
+          }),
+        ).toEqual({_key: 'k0', _type: 'stock-ticker'})
+      })
+
+      test('unknown inline object _type', () => {
+        expect(
+          parseChild({
+            context: {
+              keyGenerator: createTestKeyGenerator(),
+              schema: compileSchema(
+                defineSchema({inlineObjects: [{name: 'stock-ticker'}]}),
+              ),
+            },
+            markDefKeyMap: new Map(),
+            options: {validateFields: true},
+            child: {_type: 'image', text: 'foo'},
+          }),
+        ).toBe(undefined)
+      })
+    })
+  })
+})

package/src/utils/parse-blocks.ts

@@ -1,4 +1,4 @@
-import {isTextBlock} from '@portabletext/schema'
+import {isSpan, isTextBlock} from '@portabletext/schema'
 import type {
   PortableTextBlock,
   PortableTextListBlock,
@@ -9,7 +9,7 @@ import type {
 } from '@sanity/types'
 import type {EditorSchema} from '../editor/editor-schema'
 import type {EditorContext} from '../editor/editor-snapshot'
-import {isTypedObject} from './asserters'
+import {isRecord, isTypedObject} from './asserters'
 
 export function parseBlocks({
   context,
@@ -19,6 +19,7 @@ export function parseBlocks({
   context: Pick<EditorContext, 'keyGenerator' | 'schema'>
   blocks: unknown
   options: {
+    normalize: boolean
     removeUnusedMarkDefs: boolean
     validateFields: boolean
   }
@@ -42,6 +43,7 @@ export function parseBlock({
   context: Pick<EditorContext, 'keyGenerator' | 'schema'>
   block: unknown
   options: {
+    normalize: boolean
     removeUnusedMarkDefs: boolean
     validateFields: boolean
   }
@@ -102,6 +104,7 @@ export function parseTextBlock({
   block: unknown
   context: Pick<EditorContext, 'keyGenerator' | 'schema'>
   options: {
+    normalize: boolean
     removeUnusedMarkDefs: boolean
     validateFields: boolean
   }
@@ -186,29 +189,66 @@ export function parseTextBlock({
     ? block.children
     : []
 
-  const children = unparsedChildren
-    .map(
-      (child) =>
-        parseSpan({span: child, context, markDefKeyMap, options}) ??
-        parseInlineObject({inlineObject: child, context, options}),
-    )
+  const parsedChildren = unparsedChildren
+    .map((child) => parseChild({child, context, markDefKeyMap, options}))
     .filter((child) => child !== undefined)
-  const marks = children.flatMap((child) => child.marks ?? [])
+  const marks = parsedChildren.flatMap((child) => child.marks ?? [])
+
+  const children =
+    parsedChildren.length > 0
+      ? parsedChildren
+      : [
+          {
+            _key: context.keyGenerator(),
+            _type: context.schema.span.name,
+            text: '',
+            marks: [],
+          },
+        ]
+
+  const normalizedChildren = options.normalize
+    ? // Ensure that inline objects re surrounded by spans
+      children.reduce<Array<PortableTextObject | PortableTextSpan>>(
+        (normalizedChildren, child, index) => {
+          if (isSpan(context, child)) {
+            return [...normalizedChildren, child]
+          }
+
+          const previousChild = normalizedChildren.at(-1)
+
+          if (!previousChild || !isSpan(context, previousChild)) {
+            return [
+              ...normalizedChildren,
+              {
+                _key: context.keyGenerator(),
+                _type: context.schema.span.name,
+                text: '',
+                marks: [],
+              },
+              child,
+              ...(index === children.length - 1
+                ? [
+                    {
+                      _key: context.keyGenerator(),
+                      _type: context.schema.span.name,
+                      text: '',
+                      marks: [],
+                    },
+                  ]
+                : []),
+            ]
+          }
+
+          return [...normalizedChildren, child]
+        },
+        [],
+      )
+    : children
 
   const parsedBlock: PortableTextTextBlock = {
     _type: context.schema.block.name,
     _key,
-    children:
-      children.length > 0
-        ? children
-        : [
-            {
-              _key: context.keyGenerator(),
-              _type: context.schema.span.name,
-              text: '',
-              marks: [],
-            },
-          ],
+    children: normalizedChildren,
     markDefs: options.removeUnusedMarkDefs
       ? markDefs.filter((markDef) => marks.includes(markDef._key))
       : markDefs,
@@ -244,6 +284,23 @@ export function parseTextBlock({
   return parsedBlock
 }
 
+export function parseChild({
+  child,
+  context,
+  markDefKeyMap,
+  options,
+}: {
+  child: unknown
+  context: Pick<EditorContext, 'keyGenerator' | 'schema'>
+  markDefKeyMap: Map<string, string>
+  options: {validateFields: boolean}
+}): PortableTextSpan | PortableTextObject | undefined {
+  return (
+    parseSpan({span: child, context, markDefKeyMap, options}) ??
+    parseInlineObject({inlineObject: child, context, options})
+  )
+}
+
 export function parseSpan({
   span,
   context,
@@ -255,7 +312,7 @@ export function parseSpan({
   markDefKeyMap: Map<string, string>
   options: {validateFields: boolean}
 }): PortableTextSpan | undefined {
-  if (!isTypedObject(span)) {
+  if (!isRecord(span)) {
     return undefined
   }
 
@@ -272,11 +329,6 @@ export function parseSpan({
     }
   }
 
-  // In reality, the span schema name is always 'span', but we only the check here anyway
-  if (span._type !== context.schema.span.name || span._type !== 'span') {
-    return undefined
-  }
-
   const unparsedMarks: Array<unknown> = Array.isArray(span.marks)
     ? span.marks
     : []
@@ -300,8 +352,30 @@ export function parseSpan({
     return []
   })
 
+  if (
+    typeof span._type === 'string' &&
+    span._type !== context.schema.span.name
+  ) {
+    return undefined
+  }
+
+  if (typeof span._type !== 'string') {
+    if (typeof span.text === 'string') {
+      return {
+        _type: context.schema.span.name as 'span',
+        _key:
+          typeof span._key === 'string' ? span._key : context.keyGenerator(),
+        text: span.text,
+        marks,
+        ...(options.validateFields ? {} : customFields),
+      }
+    }
+
+    return undefined
+  }
+
   return {
-    _type: 'span',
+    _type: context.schema.span.name as 'span',
     _key: typeof span._key === 'string' ? span._key : context.keyGenerator(),
     text: typeof span.text === 'string' ? span.text : '',
     marks,

package/src/utils/util.merge-text-blocks.ts

@@ -18,7 +18,11 @@ export function mergeTextBlocks({
   const parsedIncomingBlock = parseBlock({
     context,
     block: incomingBlock,
-    options: {removeUnusedMarkDefs: true, validateFields: false},
+    options: {
+      normalize: false,
+      removeUnusedMarkDefs: true,
+      validateFields: false,
+    },
   })
 
   if (!parsedIncomingBlock || !isTextBlock(context, parsedIncomingBlock)) {