@portabletext/block-tools 4.1.8 → 4.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/block-tools",
-  "version": "4.1.8",
+  "version": "4.1.9",
   "description": "Can format HTML, Slate JSON or Sanity block array into any other format.",
   "keywords": [
     "portable-text",
@@ -33,14 +33,13 @@
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "files": [
-    "lib",
-    "src"
+    "lib"
   ],
   "dependencies": {
     "@sanity/types": "^4.20.3",
     "lodash": "^4.17.21",
-    "@portabletext/sanity-bridge": "^1.2.11",
-    "@portabletext/schema": "^2.0.0"
+    "@portabletext/sanity-bridge": "^1.2.12",
+    "@portabletext/schema": "^2.0.1"
   },
   "devDependencies": {
     "@sanity/pkg-utils": "^10.1.1",
@@ -52,7 +51,7 @@
     "jsdom": "^27.0.0",
     "typescript": "5.9.3",
     "vitest": "^4.0.14",
-    "@portabletext/test": "^1.0.1"
+    "@portabletext/test": "^1.0.2"
   },
   "engines": {
     "node": ">=20.19 <22 || >=22.12"

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

@@ -1,248 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {describe, expect, test} from 'vitest'
-import {createTestKeyGenerator} from '../../test/test-key-generator'
-import {flattenNestedBlocks} from './flatten-nested-blocks'
-
-describe(flattenNestedBlocks.name, () => {
-  test('flattening text blocks', () => {
-    const schema = compileSchema(defineSchema({}))
-    expect(
-      flattenNestedBlocks({schema}, [
-        {
-          _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 schema = compileSchema(
-      defineSchema({blockObjects: [{name: 'image'}]}),
-    )
-    expect(
-      flattenNestedBlocks({schema}, [
-        {
-          _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 schema = compileSchema(
-      defineSchema({
-        styles: [{name: 'h1'}],
-      }),
-    )
-    expect(
-      flattenNestedBlocks({schema}, [
-        {
-          _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(
-      defineSchema({
-        styles: [{name: 'h1'}],
-        annotations: [{name: 'link'}],
-        blockObjects: [{name: 'image'}],
-      }),
-    )
-    const blockKey = keyGenerator()
-    const fooKey = keyGenerator()
-    const imageKey = keyGenerator()
-    const barKey = keyGenerator()
-    const linkKey = keyGenerator()
-
-    expect(
-      flattenNestedBlocks({schema}, [
-        {
-          _key: blockKey,
-          _type: 'block',
-          children: [
-            {
-              _key: fooKey,
-              _type: 'span',
-              text: 'foo',
-            },
-            {
-              _key: imageKey,
-              _type: 'image',
-            },
-            {
-              _key: barKey,
-              _type: 'span',
-              text: 'bar',
-              marks: [linkKey],
-            },
-          ],
-          style: 'h1',
-          markDefs: [
-            {
-              _key: linkKey,
-              _type: 'link',
-            },
-          ],
-        },
-      ]),
-    ).toEqual([
-      {
-        _key: blockKey,
-        _type: 'block',
-        children: [{_key: fooKey, _type: 'span', text: 'foo'}],
-        style: 'h1',
-        markDefs: [{_key: linkKey, _type: 'link'}],
-      },
-      {
-        _key: imageKey,
-        _type: 'image',
-      },
-      {
-        _key: blockKey,
-        _type: 'block',
-        children: [
-          {_key: barKey, _type: 'span', text: 'bar', marks: [linkKey]},
-        ],
-        style: 'h1',
-        markDefs: [{_key: linkKey, _type: 'link'}],
-      },
-    ])
-  })
-
-  test('splitting text block with __block', () => {
-    const keyGenerator = createTestKeyGenerator('k')
-    const schema = compileSchema(
-      defineSchema({
-        blockObjects: [{name: 'image'}],
-      }),
-    )
-    const blockKey = keyGenerator()
-    const fooKey = keyGenerator()
-    const imageKey = keyGenerator()
-    const barKey = keyGenerator()
-
-    expect(
-      flattenNestedBlocks({schema}, [
-        {
-          _key: blockKey,
-          _type: 'block',
-          children: [
-            {
-              _key: fooKey,
-              _type: 'span',
-              text: 'foo',
-              marks: [],
-            },
-            {
-              _type: '__block',
-              block: {
-                _key: imageKey,
-                _type: 'image',
-              },
-            },
-            {
-              _key: barKey,
-              _type: 'span',
-              text: 'bar',
-              marks: [],
-            },
-          ],
-          style: 'normal',
-          markDefs: [],
-        },
-      ]),
-    ).toEqual([
-      {
-        _key: blockKey,
-        _type: 'block',
-        children: [{_key: fooKey, _type: 'span', text: 'foo', marks: []}],
-        style: 'normal',
-        markDefs: [],
-      },
-      {
-        _key: imageKey,
-        _type: 'image',
-      },
-      {
-        _key: blockKey,
-        _type: 'block',
-        children: [{_key: barKey, _type: 'span', text: 'bar', marks: []}],
-        style: 'normal',
-        markDefs: [],
-      },
-    ])
-  })
-})

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

@@ -1,173 +0,0 @@
-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
-  },
-  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,108 +0,0 @@
-import type {Schema} from '@portabletext/schema'
-import {isTextBlock, type PortableTextObject} from '@portabletext/schema'
-import {DEFAULT_BLOCK} from '../constants'
-import type {
-  ArbitraryTypedObject,
-  HtmlParser,
-  MinimalBlock,
-  MinimalSpan,
-  PlaceholderAnnotation,
-  PlaceholderDecorator,
-  TypedObject,
-} from '../types'
-import {resolveJsType} from '../util/resolveJsType'
-
-/**
- * Utility function that always return a lowerCase version of the element.tagName
- *
- * @param el - Element to get tag name for
- * @returns Lowercase tagName for that element, or undefined if not an element
- */
-export function tagName(el: HTMLElement | Node | null): string | undefined {
-  if (el && 'tagName' in el) {
-    return el.tagName.toLowerCase()
-  }
-
-  return undefined
-}
-
-/**
- * A default `parseHtml` function that returns the html using `DOMParser`.
- *
- * @returns HTML Parser based on `DOMParser`
- */
-export function defaultParseHtml(): HtmlParser {
-  if (resolveJsType(DOMParser) === 'undefined') {
-    throw new Error(
-      'The native `DOMParser` global which the `Html` deserializer uses by ' +
-        'default is not present in this environment. ' +
-        'You must supply the `options.parseHtml` function instead.',
-    )
-  }
-  return (html) => {
-    return new DOMParser().parseFromString(html, 'text/html')
-  }
-}
-
-export function ensureRootIsBlocks(
-  schema: Schema,
-  objects: Array<ArbitraryTypedObject>,
-): ArbitraryTypedObject[] {
-  return objects.reduce((blocks, node, i, original) => {
-    if (node._type === 'block') {
-      blocks.push(node)
-      return blocks
-    }
-
-    if (node._type === '__block') {
-      blocks.push((node as any).block)
-      return blocks
-    }
-
-    const lastBlock = blocks[blocks.length - 1]
-    if (
-      i > 0 &&
-      !isTextBlock({schema}, original[i - 1]) &&
-      isTextBlock({schema}, lastBlock)
-    ) {
-      lastBlock.children.push(node as PortableTextObject)
-      return blocks
-    }
-
-    const block = {
-      ...DEFAULT_BLOCK,
-      children: [node],
-    }
-
-    blocks.push(block)
-    return blocks
-  }, [] as ArbitraryTypedObject[])
-}
-
-export function isNodeList(node: unknown): node is NodeList {
-  return Object.prototype.toString.call(node) === '[object NodeList]'
-}
-
-export function isMinimalSpan(node: TypedObject): node is MinimalSpan {
-  return node._type === 'span'
-}
-
-export function isMinimalBlock(node: TypedObject): node is MinimalBlock {
-  return node._type === 'block'
-}
-
-export function isPlaceholderDecorator(
-  node: TypedObject,
-): node is PlaceholderDecorator {
-  return node._type === '__decorator'
-}
-
-export function isPlaceholderAnnotation(
-  node: TypedObject,
-): node is PlaceholderAnnotation {
-  return node._type === '__annotation'
-}
-
-export function isElement(node: Node): node is Element {
-  return node.nodeType === 1
-}