@portabletext/block-tools 4.1.8 → 4.1.10

package/src/HtmlDeserializer/rules/rules.word.ts

@@ -1,95 +0,0 @@
-import {
-  BLOCK_DEFAULT_STYLE,
-  DEFAULT_BLOCK,
-  HTML_HEADER_TAGS,
-} from '../../constants'
-import type {DeserializerRule} from '../../types'
-import {isElement, tagName} from '../helpers'
-
-function getListItemStyle(el: Node): string | undefined {
-  const style = isElement(el) && el.getAttribute('style')
-  if (!style) {
-    return undefined
-  }
-
-  if (!style.match(/lfo\d+/)) {
-    return undefined
-  }
-
-  return style.match('lfo1') ? 'number' : 'bullet'
-}
-
-function getListItemLevel(el: Node): number | undefined {
-  const style = isElement(el) && el.getAttribute('style')
-  if (!style) {
-    return undefined
-  }
-
-  const levelMatch = style.match(/level\d+/)
-  if (!levelMatch) {
-    return undefined
-  }
-
-  const [level] = levelMatch[0].match(/\d/) || []
-  const levelNum = level ? Number.parseInt(level, 10) : 1
-  return levelNum || 1
-}
-
-function isWordListElement(el: Node): boolean {
-  if (!isElement(el)) {
-    return false
-  }
-
-  // Check for specific class names
-  if (el.className) {
-    if (
-      el.className === 'MsoListParagraphCxSpFirst' ||
-      el.className === 'MsoListParagraphCxSpMiddle' ||
-      el.className === 'MsoListParagraphCxSpLast'
-    ) {
-      return true
-    }
-  }
-
-  // Check for mso-list in style attribute
-  const style = el.getAttribute('style')
-  if (style && /mso-list:\s*l\d+\s+level\d+\s+lfo\d+/.test(style)) {
-    return true
-  }
-
-  return false
-}
-
-function getHeadingStyle(el: Node): string | undefined {
-  const tag = tagName(el)
-  if (tag && HTML_HEADER_TAGS[tag]) {
-    return HTML_HEADER_TAGS[tag]?.style
-  }
-  return undefined
-}
-
-export function createWordRules(): DeserializerRule[] {
-  return [
-    {
-      deserialize(el, next) {
-        const tag = tagName(el)
-
-        // Handle list items (both paragraphs and headings)
-        if (
-          (tag === 'p' || HTML_HEADER_TAGS[tag || '']) &&
-          isWordListElement(el)
-        ) {
-          const headingStyle = getHeadingStyle(el)
-          return {
-            ...DEFAULT_BLOCK,
-            listItem: getListItemStyle(el),
-            level: getListItemLevel(el),
-            style: headingStyle || BLOCK_DEFAULT_STYLE,
-            children: next(el.childNodes),
-          }
-        }
-        return undefined
-      },
-    },
-  ]
-}

package/src/HtmlDeserializer/trim-whitespace.ts

@@ -1,157 +0,0 @@
-import {
-  isSpan,
-  isTextBlock,
-  type PortableTextTextBlock,
-  type Schema,
-} from '@portabletext/schema'
-import {isEqual} from 'lodash'
-import type {TypedObject, WhiteSpacePasteMode} from '../types'
-import {isMinimalSpan} from './helpers'
-
-export function trimWhitespace(
-  context: {schema: Schema},
-  mode: WhiteSpacePasteMode,
-  blocks: TypedObject[],
-): TypedObject[] {
-  const trimmedBlocks: TypedObject[] = []
-  let consecutiveEmptyCount = 0
-
-  for (const block of blocks) {
-    const trimmedBlock = isTextBlock(context, block)
-      ? trimTextBlockWhitespace(block)
-      : block
-
-    if (mode === 'preserve') {
-      trimmedBlocks.push(trimmedBlock)
-
-      continue
-    }
-
-    if (mode === 'remove') {
-      if (isEmptyTextBlock(context, trimmedBlock)) {
-        continue
-      }
-
-      trimmedBlocks.push(trimmedBlock)
-
-      continue
-    }
-
-    if (mode === 'normalize') {
-      if (isEmptyTextBlock(context, trimmedBlock)) {
-        consecutiveEmptyCount++
-
-        if (consecutiveEmptyCount === 1) {
-          trimmedBlocks.push(trimmedBlock)
-        }
-
-        continue
-      }
-
-      trimmedBlocks.push(trimmedBlock)
-
-      consecutiveEmptyCount = 0
-    }
-  }
-
-  return trimmedBlocks
-}
-
-function isEmptyTextBlock(
-  context: {schema: Schema},
-  block: TypedObject,
-): boolean {
-  if (!isTextBlock(context, block)) {
-    return false
-  }
-
-  if (
-    block.children.some(
-      (child) => !isSpan(context, child) || child.text.trim() !== '',
-    )
-  ) {
-    return false
-  }
-
-  return true
-}
-
-function trimTextBlockWhitespace(
-  block: PortableTextTextBlock,
-): PortableTextTextBlock {
-  let index = 0
-
-  for (const child of block.children) {
-    if (!isMinimalSpan(child)) {
-      index++
-      continue
-    }
-
-    const nextChild = nextSpan(block, index)
-    const prevChild = prevSpan(block, index)
-
-    if (index === 0) {
-      child.text = child.text.replace(/^[^\S\n]+/g, '')
-    }
-
-    if (index === block.children.length - 1) {
-      child.text = child.text.replace(/[^\S\n]+$/g, '')
-    }
-
-    if (
-      /\s/.test(child.text.slice(Math.max(0, child.text.length - 1))) &&
-      nextChild &&
-      isMinimalSpan(nextChild) &&
-      /\s/.test(nextChild.text.slice(0, 1))
-    ) {
-      child.text = child.text.replace(/[^\S\n]+$/g, '')
-    }
-
-    if (
-      /\s/.test(child.text.slice(0, 1)) &&
-      prevChild &&
-      isMinimalSpan(prevChild) &&
-      /\s/.test(prevChild.text.slice(Math.max(0, prevChild.text.length - 1)))
-    ) {
-      child.text = child.text.replace(/^[^\S\n]+/g, '')
-    }
-
-    if (!child.text) {
-      block.children.splice(index, 1)
-    }
-
-    if (
-      prevChild &&
-      isEqual(prevChild.marks, child.marks) &&
-      isWhiteSpaceChar(child.text)
-    ) {
-      prevChild.text += ' '
-      block.children.splice(index, 1)
-    } else if (
-      nextChild &&
-      isEqual(nextChild.marks, child.marks) &&
-      isWhiteSpaceChar(child.text)
-    ) {
-      nextChild.text = ` ${nextChild.text}`
-      block.children.splice(index, 1)
-    }
-
-    index++
-  }
-
-  return block
-}
-
-function nextSpan(block: PortableTextTextBlock, index: number) {
-  const next = block.children[index + 1]
-  return next && next._type === 'span' ? next : null
-}
-
-function prevSpan(block: PortableTextTextBlock, index: number) {
-  const prev = block.children[index - 1]
-  return prev && prev._type === 'span' ? prev : null
-}
-
-function isWhiteSpaceChar(text: string) {
-  return ['\xa0', ' '].includes(text)
-}

package/src/HtmlDeserializer/word-online/asserters.word-online.ts

@@ -1,153 +0,0 @@
-import {isElement, tagName} from '../helpers'
-
-export function isWordOnlineHtml(html: string): boolean {
-  return (
-    /class="(?:TextRun|NormalTextRun)[^"]*SCXW\d+[^"]*BCX\d+/.test(html) ||
-    /class="EOP[^"]*SCXW\d+/.test(html)
-  )
-}
-
-export function isWordOnlineTextRun(el: Node): boolean {
-  if (!isElement(el) || tagName(el) !== 'span') {
-    return false
-  }
-
-  return el.classList.contains('TextRun') && !el.classList.contains('EOP')
-}
-
-/**
- * Identifies the inner text holder spans in Word Online's nested structure.
- * Word Online uses: <span class="TextRun"><span class="NormalTextRun">text</span></span>
- * This function matches the inner span where actual text content lives.
- * Use this to find the text-bearing children within a TextRun container.
- */
-export function isNormalTextRun(el: Node): boolean {
-  if (!isElement(el) || tagName(el) !== 'span') {
-    return false
-  }
-
-  return el.classList.contains('NormalTextRun')
-}
-
-/**
- * Identifies the outer container spans in Word Online's nested structure.
- * Word Online uses: <span class="TextRun"><span class="NormalTextRun">text</span></span>
- * This function matches the outer span that holds formatting and contains NormalTextRun children.
- * Use this to find the top-level containers, then search within for NormalTextRun spans.
- * Note: Excludes spans that also have "NormalTextRun" or "EOP" classes.
- */
-export function isTextRunSpan(el: Node): boolean {
-  if (!isElement(el) || tagName(el) !== 'span') {
-    return false
-  }
-
-  return (
-    el.classList.contains('TextRun') &&
-    !el.classList.contains('NormalTextRun') &&
-    !el.classList.contains('EOP')
-  )
-}
-
-export function isEmptyOutlineElement(el: Element): boolean {
-  if (!isElement(el)) {
-    return false
-  }
-
-  if (!el.classList.contains('OutlineElement')) {
-    return false
-  }
-
-  return el.textContent.trim() === ''
-}
-
-export function isFindHit(el: Node): boolean {
-  if (!isElement(el) || tagName(el) !== 'span') {
-    return false
-  }
-
-  return el.classList.contains('FindHit')
-}
-
-export function isInHeading(el: Node): boolean {
-  let current: Node | null = el
-
-  while (current) {
-    if (isElement(current)) {
-      if (
-        tagName(current) === 'word-online-block' &&
-        /^heading \d$/.test(current.getAttribute('data-parastyle') ?? '')
-      ) {
-        return true
-      }
-    }
-
-    current = current.parentNode
-  }
-
-  return false
-}
-
-export function isInBlockquote(el: Node): boolean {
-  let current: Node | null = el
-
-  while (current) {
-    if (isElement(current)) {
-      if (
-        tagName(current) === 'word-online-block' &&
-        current.getAttribute('data-parastyle') === 'Quote'
-      ) {
-        return true
-      }
-    }
-
-    current = current.parentNode
-  }
-
-  return false
-}
-
-/**********************
- * Formatting asserters
- **********************/
-
-export function hasStrongFormatting(el: Element): boolean {
-  const style = el.getAttribute('style') ?? ''
-
-  return (
-    el.classList.contains('MacChromeBold') ||
-    /font-weight\s*:\s*bold/.test(style)
-  )
-}
-
-export function hasEmphasisFormatting(el: Element): boolean {
-  const style = el.getAttribute('style') ?? ''
-
-  return /font-style\s*:\s*italic/.test(style)
-}
-
-export function hasUnderlineFormatting(el: Element): boolean {
-  const style = el.getAttribute('style') ?? ''
-
-  return (
-    el.classList.contains('Underlined') ||
-    /text-decoration\s*:\s*underline/.test(style)
-  )
-}
-
-export function hasStrikethroughFormatting(el: Element): boolean {
-  const style = el.getAttribute('style') ?? ''
-
-  return (
-    el.classList.contains('Strikethrough') ||
-    /text-decoration\s*:\s*line-through/.test(style)
-  )
-}
-
-export function hasFormatting(el: Element): boolean {
-  return (
-    hasStrongFormatting(el) ||
-    hasEmphasisFormatting(el) ||
-    hasUnderlineFormatting(el) ||
-    hasStrikethroughFormatting(el)
-  )
-}

package/src/HtmlDeserializer/word-online/preprocessor.word-online.ts

@@ -1,263 +0,0 @@
-import {isElement, tagName} from '../helpers'
-import {
-  hasFormatting,
-  isNormalTextRun,
-  isTextRunSpan,
-  isWordOnlineHtml,
-} from './asserters.word-online'
-
-export function preprocessWordOnline(html: string, doc: Document): Document {
-  if (!isWordOnlineHtml(html)) {
-    return doc
-  }
-
-  const paragraphs = Array.from(
-    doc.querySelectorAll('p.Paragraph[role="heading"]'),
-  )
-
-  for (const paragraph of paragraphs) {
-    const ariaLevel = paragraph.getAttribute('aria-level')
-
-    if (ariaLevel) {
-      const wrapper = doc.createElement('word-online-block')
-
-      wrapper.setAttribute('data-parastyle', `heading ${ariaLevel}`)
-
-      const parent = paragraph.parentNode
-
-      if (parent) {
-        parent.insertBefore(wrapper, paragraph)
-
-        while (paragraph.firstChild) {
-          wrapper.appendChild(paragraph.firstChild)
-        }
-
-        parent.removeChild(paragraph)
-      }
-    }
-  }
-
-  // Group NormalTextRun spans with the same data-ccp-parastyle attribute
-  // This handles cases like blockquotes, headings where multiple spans should form one block
-  // Process from the body directly to handle DOM mutations
-  let child = doc.body.firstChild
-
-  while (child) {
-    const next = child.nextSibling
-
-    if (!isElement(child) || !tagName(child)?.includes('span')) {
-      child = next
-
-      continue
-    }
-
-    const paraStyle = getParaStyle(child)
-
-    if (!paraStyle) {
-      child = next
-
-      continue
-    }
-
-    // Found a span with paragraph style - collect all consecutive siblings with same style
-    const group: Element[] = [child]
-    let sibling = next
-
-    while (sibling) {
-      if (!isElement(sibling) || getParaStyle(sibling) !== paraStyle) {
-        break
-      }
-
-      group.push(sibling)
-      sibling = sibling.nextSibling
-    }
-
-    // Wrap the spans in a container
-    // Use a custom element name to avoid conflicts with HTML rules
-    const wrapper = doc.createElement('word-online-block')
-    wrapper.setAttribute('data-parastyle', paraStyle)
-
-    // Insert the wrapper before the first span
-    doc.body.insertBefore(wrapper, child)
-
-    // Move all grouped spans into the wrapper
-    for (const span of group) {
-      wrapper.appendChild(span)
-    }
-
-    // Continue with the sibling after the last grouped span
-    child = sibling
-  }
-
-  // Find all TextRun spans
-  const textRunSpans = Array.from(doc.body.querySelectorAll('span')).filter(
-    isTextRunSpan,
-  )
-
-  for (const textRunSpan of textRunSpans) {
-    // Find ALL NormalTextRun children (Word Online can have multiple per TextRun)
-    const normalTextRuns = Array.from(textRunSpan.childNodes).filter(
-      isNormalTextRun,
-    )
-
-    for (const normalTextRun of normalTextRuns) {
-      // Process ALL nested spans with whitespace in this NormalTextRun
-      // We need to process them in a loop since removing one might affect indices
-      let foundNestedSpan = true
-
-      while (foundNestedSpan) {
-        const children = Array.from(normalTextRun.childNodes)
-        const nestedSpanIndex = children.findIndex(
-          (node) =>
-            isElement(node) &&
-            tagName(node) === 'span' &&
-            node.textContent.trim() === '',
-        )
-
-        if (nestedSpanIndex === -1) {
-          foundNestedSpan = false
-          break
-        }
-
-        const nestedSpan = children.at(nestedSpanIndex)
-
-        if (!nestedSpan) {
-          foundNestedSpan = false
-          break
-        }
-
-        // Word Online uses non-breaking spaces, convert to regular spaces
-        const spaceText = nestedSpan.textContent?.replace(/\u00a0/g, ' ') ?? ''
-
-        // Determine if the space is at the beginning or end BEFORE removing it
-        // Check if there are any text nodes before this position
-        const hasTextBefore = children
-          .slice(0, nestedSpanIndex)
-          .some((n) => n.nodeType === 3)
-        const isSpaceAtBeginning = !hasTextBefore
-
-        // Remove the nested span
-        normalTextRun.removeChild(nestedSpan)
-
-        if (isSpaceAtBeginning) {
-          // Space at the beginning - keep it at the beginning
-          const firstTextNode = Array.from(normalTextRun.childNodes).find(
-            (n) => n.nodeType === 3,
-          )
-
-          if (firstTextNode) {
-            firstTextNode.textContent =
-              spaceText + (firstTextNode.textContent || '')
-          } else {
-            // No text node exists, create one with the space
-            const spaceNode = doc.createTextNode(spaceText)
-            normalTextRun.insertBefore(spaceNode, normalTextRun.firstChild)
-          }
-        } else {
-          // Space at the end - check if we should move it to the next TextRun
-          // Only move if the formatting (marks) are different
-          const nextSibling = textRunSpan.nextSibling
-          const currentHasFormatting = hasFormatting(textRunSpan)
-
-          if (
-            nextSibling &&
-            isElement(nextSibling) &&
-            isTextRunSpan(nextSibling)
-          ) {
-            const nextHasFormatting = hasFormatting(nextSibling)
-
-            // If current has formatting but next doesn't, move space to the next span
-            // This makes semantic sense: "**bar** baz" or "*bar* baz" → space should be outside the formatting
-            if (currentHasFormatting && !nextHasFormatting) {
-              const nextNormalTextRun = Array.from(nextSibling.childNodes).find(
-                isNormalTextRun,
-              )
-
-              if (nextNormalTextRun && isElement(nextNormalTextRun)) {
-                // Prepend space to the first text node of the next NormalTextRun
-                const firstChild = nextNormalTextRun.firstChild
-
-                if (firstChild && firstChild.nodeType === 3) {
-                  firstChild.textContent =
-                    spaceText + (firstChild.textContent ?? '')
-                } else {
-                  // No text node, insert a new one at the beginning
-                  const spaceNode = doc.createTextNode(spaceText)
-                  nextNormalTextRun.insertBefore(
-                    spaceNode,
-                    nextNormalTextRun.firstChild,
-                  )
-                }
-              }
-              // Don't add the space back to the current span - it's been moved
-            } else {
-              // Same formatting, keep the space in the current span
-              const lastTextNode = Array.from(normalTextRun.childNodes).find(
-                (n) => n.nodeType === 3,
-              )
-
-              if (lastTextNode) {
-                lastTextNode.textContent =
-                  (lastTextNode.textContent ?? '') + spaceText
-              } else {
-                // No text node exists, create one with the space
-                const spaceNode = doc.createTextNode(spaceText)
-                normalTextRun.appendChild(spaceNode)
-              }
-            }
-          } else {
-            // No next TextRun, keep the space at the end of this span's text
-            const lastTextNode = Array.from(normalTextRun.childNodes).find(
-              (n) => n.nodeType === 3,
-            )
-
-            if (lastTextNode) {
-              lastTextNode.textContent =
-                (lastTextNode.textContent ?? '') + spaceText
-            } else {
-              // No text node exists, create one with the space
-              const spaceNode = doc.createTextNode(spaceText)
-              normalTextRun.appendChild(spaceNode)
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return doc
-}
-
-// Helper to get paragraph style from a span (either directly or from NormalTextRun child)
-function getParaStyle(element: Element): string | undefined {
-  // Check direct attribute first
-  const directStyle = element.getAttribute('data-ccp-parastyle')
-
-  if (directStyle) {
-    return directStyle
-  }
-
-  // Check if it's a TextRun with NormalTextRun children that have the attribute
-  if (tagName(element) === 'span' && element.classList.contains('TextRun')) {
-    const normalTextRuns = Array.from(
-      element.querySelectorAll('.NormalTextRun'),
-    )
-
-    if (normalTextRuns.length > 0) {
-      const firstStyle = normalTextRuns[0].getAttribute('data-ccp-parastyle')
-
-      // Verify all NormalTextRuns have the same style
-      if (
-        firstStyle &&
-        normalTextRuns.every(
-          (normalTextRun) =>
-            normalTextRun.getAttribute('data-ccp-parastyle') === firstStyle,
-        )
-      ) {
-        return firstStyle
-      }
-    }
-  }
-
-  return undefined
-}