@portabletext/block-tools 3.3.3 → 3.4.1

package/src/HtmlDeserializer/flatten-nested-blocks.test.ts

@@ -1,9 +1,120 @@
 import {compileSchema, defineSchema} from '@portabletext/schema'
 import {describe, expect, test} from 'vitest'
 import {createTestKeyGenerator} from '../../test/test-key-generator'
-import {flattenNestedBlocks} from './helpers'
+import {flattenNestedBlocks} from './flatten-nested-blocks'
 
 describe(flattenNestedBlocks.name, () => {
+  test('flattening text blocks', () => {
+    const keyGenerator = createTestKeyGenerator('k')
+    const schema = compileSchema(defineSchema({}))
+    expect(
+      flattenNestedBlocks({schema, keyGenerator}, [
+        {
+          _type: 'block',
+          children: [
+            {
+              _type: 'block',
+              children: [
+                {
+                  _type: 'span',
+                  marks: [],
+                  text: 'foo',
+                },
+              ],
+              markDefs: [],
+              style: 'normal',
+            },
+          ],
+          markDefs: [],
+          style: 'normal',
+        },
+      ]),
+    ).toEqual([
+      {
+        _type: 'block',
+        children: [{_type: 'span', text: 'foo', marks: []}],
+        markDefs: [],
+        style: 'normal',
+      },
+    ])
+  })
+
+  test('flattening text blocks with block objects in schema', () => {
+    const keyGenerator = createTestKeyGenerator('k')
+    const schema = compileSchema(
+      defineSchema({blockObjects: [{name: 'image'}]}),
+    )
+    expect(
+      flattenNestedBlocks({schema, keyGenerator}, [
+        {
+          _type: 'block',
+          children: [
+            {
+              _type: 'block',
+              children: [
+                {
+                  _type: 'span',
+                  text: 'foo',
+                  marks: [],
+                },
+              ],
+              markDefs: [],
+              style: 'normal',
+            },
+          ],
+          markDefs: [],
+          style: 'normal',
+        },
+      ]),
+    ).toEqual([
+      {
+        _type: 'block',
+        children: [{_type: 'span', text: 'foo', marks: []}],
+        markDefs: [],
+        style: 'normal',
+      },
+    ])
+  })
+
+  test('flattening text blocks with styles in schema', () => {
+    const keyGenerator = createTestKeyGenerator('k')
+    const schema = compileSchema(
+      defineSchema({
+        styles: [{name: 'h1'}],
+      }),
+    )
+    expect(
+      flattenNestedBlocks({schema, keyGenerator}, [
+        {
+          _type: 'block',
+          children: [
+            {
+              _type: 'block',
+              children: [
+                {
+                  _type: 'span',
+                  marks: [],
+                  text: 'foo',
+                },
+              ],
+              markDefs: [],
+              style: 'normal',
+            },
+          ],
+          markDefs: [],
+          style: 'h1',
+        },
+      ]),
+    ).toEqual([
+      {
+        _type: 'block',
+        children: [{_type: 'span', text: 'foo', marks: []}],
+        markDefs: [],
+        style: 'normal',
+      },
+    ])
+  })
+
   test('splitting text block', () => {
     const keyGenerator = createTestKeyGenerator('k')
     const schema = compileSchema(

package/src/HtmlDeserializer/flatten-nested-blocks.ts

@@ -0,0 +1,174 @@
+import type {Schema} from '@portabletext/schema'
+import {
+  isSpan,
+  isTextBlock,
+  type PortableTextBlock,
+  type PortableTextObject,
+  type PortableTextSpan,
+  type PortableTextTextBlock,
+} from '@portabletext/schema'
+import {isEqual} from 'lodash'
+import {
+  isArbitraryTypedObject,
+  type ArbitraryTypedObject,
+  type TypedObject,
+} from '../types'
+
+export function flattenNestedBlocks(
+  context: {
+    schema: Schema
+    keyGenerator: () => string
+  },
+  blocks: Array<ArbitraryTypedObject>,
+): TypedObject[] {
+  const flattened = blocks.flatMap((block) => {
+    if (isBlockContainer(block)) {
+      return flattenNestedBlocks(context, [block.block])
+    }
+
+    if (isTextBlock(context, block)) {
+      const hasBlockObjects = block.children.some((child) => {
+        const knownBlockObject = context.schema.blockObjects.some(
+          (blockObject) => blockObject.name === child._type,
+        )
+        return knownBlockObject
+      })
+      const hasBlocks = block.children.some(
+        (child) => child._type === '__block' || child._type === 'block',
+      )
+
+      if (hasBlockObjects || hasBlocks) {
+        const splitChildren = getSplitChildren(context, block)
+
+        if (
+          splitChildren.length === 1 &&
+          splitChildren[0].type === 'children' &&
+          isEqual(splitChildren[0].children, block.children)
+        ) {
+          return [block]
+        }
+
+        return splitChildren.flatMap((slice) => {
+          if (slice.type === 'block object') {
+            return [slice.block]
+          }
+
+          if (slice.type === 'block') {
+            return flattenNestedBlocks(context, [
+              slice.block as ArbitraryTypedObject,
+            ])
+          }
+
+          if (slice.children.length > 0) {
+            if (
+              slice.children.every(
+                (child) => isSpan(context, child) && child.text.trim() === '',
+              )
+            ) {
+              return []
+            }
+
+            return flattenNestedBlocks(context, [
+              {
+                ...block,
+                children: slice.children,
+              },
+            ])
+          }
+
+          return []
+        })
+      }
+
+      return [block]
+    }
+
+    return [block]
+  })
+
+  return flattened
+}
+
+function isBlockContainer(
+  block: ArbitraryTypedObject,
+): block is BlockContainer {
+  return block._type === '__block' && isArbitraryTypedObject(block.block)
+}
+
+type BlockContainer = {
+  _type: '__block'
+  block: ArbitraryTypedObject
+}
+
+function getSplitChildren(
+  context: {schema: Schema},
+  block: PortableTextTextBlock,
+) {
+  return block.children.reduce(
+    (slices, child) => {
+      const knownInlineObject = context.schema.inlineObjects.some(
+        (inlineObject) => inlineObject.name === child._type,
+      )
+      const knownBlockObject = context.schema.blockObjects.some(
+        (blockObject) => blockObject.name === child._type,
+      )
+
+      const lastSlice = slices.pop()
+
+      if (!isSpan(context, child) && !knownInlineObject) {
+        if (knownBlockObject) {
+          return [
+            ...slices,
+            ...(lastSlice ? [lastSlice] : []),
+            {type: 'block object' as const, block: child},
+          ]
+        }
+      }
+
+      if (child._type === '__block') {
+        return [
+          ...slices,
+          ...(lastSlice ? [lastSlice] : []),
+          {
+            type: 'block object' as const,
+            block: (child as any).block,
+          },
+        ]
+      }
+
+      if (child._type === 'block') {
+        return [
+          ...slices,
+          ...(lastSlice ? [lastSlice] : []),
+          {type: 'block' as const, block: child},
+        ]
+      }
+
+      if (lastSlice) {
+        if (lastSlice.type === 'children') {
+          return [
+            ...slices,
+            {
+              type: 'children' as const,
+              children: [...lastSlice.children, child],
+            },
+          ]
+        }
+      }
+
+      return [
+        ...slices,
+        ...(lastSlice ? [lastSlice] : []),
+        {type: 'children' as const, children: [child]},
+      ]
+    },
+    [] as Array<
+      | {
+          type: 'children'
+          children: Array<PortableTextSpan | PortableTextObject>
+        }
+      | {type: 'block object'; block: PortableTextObject}
+      | {type: 'block'; block: PortableTextBlock}
+    >,
+  )
+}

package/src/HtmlDeserializer/helpers.ts

@@ -1,4 +1,9 @@
 import type {Schema} from '@portabletext/schema'
+import {
+  isTextBlock,
+  type PortableTextObject,
+  type PortableTextTextBlock,
+} from '@portabletext/schema'
 import {vercelStegaClean} from '@vercel/stega'
 import {isEqual} from 'lodash'
 import {DEFAULT_BLOCK} from '../constants'
@@ -12,13 +17,6 @@ import type {
   PlaceholderDecorator,
   TypedObject,
 } from '../types'
-import {
-  isSpan,
-  isTextBlock,
-  type PortableTextObject,
-  type PortableTextSpan,
-  type PortableTextTextBlock,
-} from '../types.portable-text'
 import {resolveJsType} from '../util/resolveJsType'
 import preprocessors from './preprocessors'
 
@@ -72,143 +70,6 @@ export function defaultParseHtml(): HtmlParser {
   }
 }
 
-export function flattenNestedBlocks(
-  context: {
-    schema: Schema
-    keyGenerator: () => string
-  },
-  blocks: Array<ArbitraryTypedObject>,
-): TypedObject[] {
-  let depth = 0
-  const flattened: TypedObject[] = []
-
-  const traverse = (nodes: TypedObject[]) => {
-    const toRemove: TypedObject[] = []
-    nodes.forEach((node) => {
-      if (depth === 0) {
-        //Only apply splitting logic if we have block objects defined in the schema
-        if (
-          context.schema.blockObjects.length > 0 &&
-          isTextBlock(context.schema, node)
-        ) {
-          const hasBlockObjects = node.children.some((child) => {
-            const knownBlockObject = context.schema.blockObjects.some(
-              (blockObject) => blockObject.name === child._type,
-            )
-            return knownBlockObject
-          })
-          const hasBlocks = node.children.some(
-            (child) => child._type === '__block',
-          )
-
-          if (hasBlockObjects || hasBlocks) {
-            // Split the block when it contains block objects
-            const splitChildren = node.children.reduce(
-              (slices, child) => {
-                const knownInlineObject = context.schema.inlineObjects.some(
-                  (inlineObject) => inlineObject.name === child._type,
-                )
-                const knownBlockObject = context.schema.blockObjects.some(
-                  (blockObject) => blockObject.name === child._type,
-                )
-
-                const lastSlice = slices.pop()
-
-                if (!isSpan(context.schema, child) && !knownInlineObject) {
-                  if (knownBlockObject) {
-                    return [
-                      ...slices,
-                      ...(lastSlice ? [lastSlice] : []),
-                      {type: 'block object' as const, block: child},
-                    ]
-                  }
-                }
-
-                if (child._type === '__block') {
-                  return [
-                    ...slices,
-                    ...(lastSlice ? [lastSlice] : []),
-                    {
-                      type: 'block object' as const,
-                      block: (child as any).block,
-                    },
-                  ]
-                }
-
-                if (lastSlice) {
-                  if (lastSlice.type === 'children') {
-                    return [
-                      ...slices,
-                      {
-                        type: 'children' as const,
-                        children: [...lastSlice.children, child],
-                      },
-                    ]
-                  }
-                }
-
-                return [
-                  ...slices,
-                  ...(lastSlice ? [lastSlice] : []),
-                  {type: 'children' as const, children: [child]},
-                ]
-              },
-              [] as Array<
-                | {
-                    type: 'children'
-                    children: Array<PortableTextSpan | PortableTextObject>
-                  }
-                | {type: 'block object'; block: PortableTextObject}
-              >,
-            )
-
-            // Process each slice
-            splitChildren.forEach((slice) => {
-              if (slice.type === 'block object') {
-                // Add the block object directly
-                flattened.push(slice.block)
-              } else if (slice.children.length > 0) {
-                // Create a new text block with the remaining children
-                const newBlock = {
-                  ...node,
-                  children: slice.children,
-                }
-                flattened.push(newBlock)
-              }
-            })
-            return
-          } else {
-            // No block objects, add the block as is
-            flattened.push(node)
-          }
-        } else {
-          //Not a text block or no block objects in schema, add directly
-          flattened.push(node)
-        }
-      }
-
-      if (isTextBlock(context.schema, node)) {
-        if (depth > 0) {
-          toRemove.push(node)
-          flattened.push(node)
-        }
-        depth++
-        traverse(node.children)
-      }
-      if (node._type === '__block') {
-        toRemove.push(node)
-        flattened.push((node as any).block)
-      }
-    })
-    toRemove.forEach((node) => {
-      nodes.splice(nodes.indexOf(node), 1)
-    })
-    depth--
-  }
-  traverse(blocks)
-  return flattened
-}
-
 function nextSpan(block: PortableTextTextBlock, index: number) {
   const next = block.children[index + 1]
   return next && next._type === 'span' ? next : null
@@ -234,7 +95,7 @@ export function trimWhitespace(
   blocks: TypedObject[],
 ): TypedObject[] {
   blocks.forEach((block) => {
-    if (!isTextBlock(schema, block)) {
+    if (!isTextBlock({schema}, block)) {
       return
     }
 
@@ -293,27 +154,27 @@ export function trimWhitespace(
 
 export function ensureRootIsBlocks(
   schema: Schema,
-  blocks: Array<ArbitraryTypedObject>,
+  objects: Array<ArbitraryTypedObject>,
 ): ArbitraryTypedObject[] {
-  return blocks.reduce((memo, node, i, original) => {
+  return objects.reduce((blocks, node, i, original) => {
     if (node._type === 'block') {
-      memo.push(node)
-      return memo
+      blocks.push(node)
+      return blocks
     }
 
     if (node._type === '__block') {
-      memo.push((node as any).block)
-      return memo
+      blocks.push((node as any).block)
+      return blocks
     }
 
-    const lastBlock = memo[memo.length - 1]
+    const lastBlock = blocks[blocks.length - 1]
     if (
       i > 0 &&
-      !isTextBlock(schema, original[i - 1]) &&
-      isTextBlock(schema, lastBlock)
+      !isTextBlock({schema}, original[i - 1]) &&
+      isTextBlock({schema}, lastBlock)
     ) {
       lastBlock.children.push(node as PortableTextObject)
-      return memo
+      return blocks
     }
 
     const block = {
@@ -321,8 +182,8 @@ export function ensureRootIsBlocks(
       children: [node],
     }
 
-    memo.push(block)
-    return memo
+    blocks.push(block)
+    return blocks
   }, [] as ArbitraryTypedObject[])
 }
 
@@ -393,7 +254,9 @@ export function normalizeWhitespace(rootNode: Node) {
   }
 
   // Remove marked nodes
-  nodesToRemove.forEach((node) => node.parentElement?.removeChild(node))
+  nodesToRemove.forEach((node) => {
+    node.parentElement?.removeChild(node)
+  })
 }
 
 /**
@@ -438,7 +301,9 @@ export function removeAllWhitespace(rootNode: Node) {
   collectNodesToRemove(rootNode)
 
   // Remove the collected nodes
-  nodesToRemove.forEach((node) => node.parentElement?.removeChild(node))
+  nodesToRemove.forEach((node) => {
+    node.parentElement?.removeChild(node)
+  })
 }
 
 function isWhitespaceBlock(elm: HTMLElement): boolean {

package/src/HtmlDeserializer/index.ts

@@ -1,4 +1,9 @@
 import type {Schema} from '@portabletext/schema'
+import {
+  isTextBlock,
+  type PortableTextBlock,
+  type PortableTextObject,
+} from '@portabletext/schema'
 import {flatten} from 'lodash'
 import type {
   ArbitraryTypedObject,
@@ -8,17 +13,12 @@ import type {
   PlaceholderDecorator,
   TypedObject,
 } from '../types'
-import {
-  isTextBlock,
-  type PortableTextBlock,
-  type PortableTextObject,
-} from '../types.portable-text'
 import {keyGenerator} from '../util/randomKey'
 import {resolveJsType} from '../util/resolveJsType'
+import {flattenNestedBlocks} from './flatten-nested-blocks'
 import {
   defaultParseHtml,
   ensureRootIsBlocks,
-  flattenNestedBlocks,
   isMinimalBlock,
   isMinimalSpan,
   isNodeList,
@@ -88,7 +88,7 @@ export default class HtmlDeserializer {
 
     if (this._markDefs.length > 0) {
       blocks
-        .filter((block) => isTextBlock(this.schema, block))
+        .filter((block) => isTextBlock({schema: this.schema}, block))
         .forEach((block) => {
           block.markDefs = block.markDefs || []
           block.markDefs = block.markDefs.concat(

package/src/HtmlDeserializer/rules/html.ts

@@ -266,6 +266,18 @@ export default function createHTMLRules(
         )
       },
     },
+    {
+      deserialize(el, next) {
+        if (isElement(el) && (tagName(el) === 'td' || tagName(el) === 'th')) {
+          return {
+            ...DEFAULT_BLOCK,
+            children: next(el.childNodes),
+          }
+        }
+
+        return undefined
+      },
+    },
     {
       deserialize(el) {
         if (isElement(el) && tagName(el) === 'img') {

package/src/index.ts

@@ -36,7 +36,7 @@ export type {
   PortableTextObject,
   PortableTextSpan,
   PortableTextTextBlock,
-} from './types.portable-text'
+} from '@portabletext/schema'
 export type {BlockNormalizationOptions} from './util/normalizeBlock'
 export {randomKey} from './util/randomKey'
 export {normalizeBlock}

package/src/types.ts

@@ -1,5 +1,5 @@
+import type {PortableTextObject} from '@portabletext/schema'
 import type {SchemaMatchers} from './schema-matchers'
-import type {PortableTextObject} from './types.portable-text'
 
 /**
  * @public

package/src/util/normalizeBlock.ts

@@ -1,11 +1,11 @@
 import type {Schema} from '@portabletext/schema'
-import {isEqual} from 'lodash'
-import type {TypedObject} from '../types'
 import {
   isSpan,
   type PortableTextSpan,
   type PortableTextTextBlock,
-} from '../types.portable-text'
+} from '@portabletext/schema'
+import {isEqual} from 'lodash'
+import type {TypedObject} from '../types'
 import {keyGenerator} from './randomKey'
 
 /**
@@ -115,8 +115,8 @@ export function normalizeBlock(
         const previousChild = acc[acc.length - 1]
         if (
           previousChild &&
-          isSpan(schema, child) &&
-          isSpan(schema, previousChild) &&
+          isSpan({schema}, child) &&
+          isSpan({schema}, previousChild) &&
           isEqual(previousChild.marks, child.marks)
         ) {
           if (
@@ -145,7 +145,7 @@ export function normalizeBlock(
         ? options.keyGenerator()
         : keyGenerator()
 
-      if (isSpan(schema, child)) {
+      if (isSpan({schema}, child)) {
         if (!child.marks) {
           child.marks = []
         } else if (allowedDecorators) {