@portabletext/block-tools 4.1.8 → 4.1.10

package/src/HtmlDeserializer/index.ts

@@ -1,315 +0,0 @@
-import type {Schema} from '@portabletext/schema'
-import {
-  isTextBlock,
-  type PortableTextBlock,
-  type PortableTextObject,
-} from '@portabletext/schema'
-import {vercelStegaClean} from '@vercel/stega'
-import {flatten} from 'lodash'
-import type {
-  ArbitraryTypedObject,
-  DeserializerRule,
-  HtmlDeserializerOptions,
-  PlaceholderAnnotation,
-  PlaceholderDecorator,
-  TypedObject,
-} from '../types'
-import {keyGenerator} from '../util/randomKey'
-import {resolveJsType} from '../util/resolveJsType'
-import {flattenNestedBlocks} from './flatten-nested-blocks'
-import {
-  defaultParseHtml,
-  ensureRootIsBlocks,
-  isMinimalBlock,
-  isMinimalSpan,
-  isNodeList,
-  isPlaceholderAnnotation,
-  isPlaceholderDecorator,
-  tagName,
-} from './helpers'
-import {preprocessors} from './preprocessors'
-import {createRules} from './rules'
-import {trimWhitespace} from './trim-whitespace'
-
-/**
- * HTML Deserializer
- *
- */
-export default class HtmlDeserializer {
-  keyGenerator: () => string
-  schema: Schema
-  rules: DeserializerRule[]
-  parseHtml: (html: string) => HTMLElement
-  whitespaceMode: 'preserve' | 'remove' | 'normalize'
-  _markDefs: PortableTextObject[] = []
-
-  /**
-   * Create a new serializer respecting a Sanity block content type's schema
-   *
-   * @param blockContentType - Schema type for array containing _at least_ a block child type
-   * @param options - Options for the deserialization process
-   */
-  constructor(schema: Schema, options: HtmlDeserializerOptions = {}) {
-    const {rules = [], unstable_whitespaceOnPasteMode = 'preserve'} = options
-    const standardRules = createRules(schema, {
-      keyGenerator: options.keyGenerator,
-      matchers: options.matchers,
-    })
-    this.schema = schema
-    this.keyGenerator = options.keyGenerator ?? keyGenerator
-    this.rules = [...rules, ...standardRules]
-    this.whitespaceMode = unstable_whitespaceOnPasteMode
-    const parseHtml = options.parseHtml || defaultParseHtml()
-    this.parseHtml = (html) => {
-      const cleanHTML = vercelStegaClean(html)
-      const doc = parseHtml(cleanHTML)
-
-      for (const processor of preprocessors) {
-        processor(cleanHTML, doc)
-      }
-
-      return doc.body
-    }
-  }
-
-  /**
-   * Deserialize HTML.
-   *
-   * @param html - The HTML to deserialize, as a string
-   * @returns Array of blocks - either portable text blocks or other allowed blocks
-   */
-  deserialize = (html: string): TypedObject[] => {
-    this._markDefs = []
-    const {parseHtml} = this
-    const fragment = parseHtml(html)
-    const children = Array.from(fragment.childNodes) as HTMLElement[]
-
-    const blocks = trimWhitespace(
-      {schema: this.schema},
-      this.whitespaceMode,
-      flattenNestedBlocks(
-        {schema: this.schema},
-        ensureRootIsBlocks(
-          this.schema,
-          this.deserializeElements(children) as Array<ArbitraryTypedObject>,
-        ),
-      ),
-    )
-
-    if (this._markDefs.length > 0) {
-      blocks
-        .filter((block) => isTextBlock({schema: this.schema}, block))
-        .forEach((block) => {
-          block.markDefs = block.markDefs || []
-          block.markDefs = block.markDefs.concat(
-            this._markDefs.filter((def) => {
-              return flatten(
-                block.children.map((child) => child.marks || []),
-              ).includes(def._key)
-            }),
-          )
-        })
-    }
-
-    return blocks.map((block) => {
-      if (block._type === 'block') {
-        block._type = this.schema.block.name
-      }
-      return block
-    })
-  }
-
-  /**
-   * Deserialize an array of DOM elements.
-   *
-   * @param elements - Array of DOM elements to deserialize
-   * @returns
-   */
-  deserializeElements = (elements: Node[] = []): TypedObject[] => {
-    let nodes: TypedObject[] = []
-    elements.forEach((element) => {
-      nodes = nodes.concat(this.deserializeElement(element))
-    })
-    return nodes
-  }
-
-  /**
-   * Deserialize a DOM element
-   *
-   * @param element - Deserialize a DOM element
-   * @returns
-   */
-  deserializeElement = (element: Node): TypedObject | TypedObject[] => {
-    const next = (
-      elements: Node | Node[] | NodeList,
-    ): TypedObject | TypedObject[] | undefined => {
-      if (isNodeList(elements)) {
-        return this.deserializeElements(Array.from(elements))
-      }
-
-      if (Array.isArray(elements)) {
-        return this.deserializeElements(elements)
-      }
-
-      if (!elements) {
-        return undefined
-      }
-
-      return this.deserializeElement(elements)
-    }
-
-    const block = (props: ArbitraryTypedObject) => {
-      return {
-        _type: '__block',
-        block: props,
-      }
-    }
-
-    let node: TypedObject | Array<TypedObject> | undefined
-    for (let i = 0; i < this.rules.length; i++) {
-      const rule = this.rules[i]
-      if (!rule.deserialize) {
-        continue
-      }
-
-      const ret = rule.deserialize(element, next, block)
-      const type = resolveJsType(ret)
-
-      if (
-        type !== 'array' &&
-        type !== 'object' &&
-        type !== 'null' &&
-        type !== 'undefined'
-      ) {
-        throw new Error(
-          `A rule returned an invalid deserialized representation: "${node}".`,
-        )
-      }
-
-      if (ret === undefined) {
-        continue
-      } else if (ret === null) {
-        throw new Error('Deserializer rule returned `null`')
-      } else if (Array.isArray(ret)) {
-        node = ret
-      } else if (isPlaceholderDecorator(ret)) {
-        node = this.deserializeDecorator(ret)
-      } else if (isPlaceholderAnnotation(ret)) {
-        node = this.deserializeAnnotation(ret)
-      } else {
-        node = ret
-      }
-
-      // Set list level on list item
-      if (
-        ret &&
-        !Array.isArray(ret) &&
-        isMinimalBlock(ret) &&
-        'listItem' in ret
-      ) {
-        let parent = element.parentNode?.parentNode
-        while (parent && tagName(parent) === 'li') {
-          parent = parent.parentNode?.parentNode
-          ret.level = ret.level ? ret.level + 1 : 1
-        }
-      }
-
-      // Set newlines on spans orginating from a block element within a blockquote
-      if (
-        ret &&
-        !Array.isArray(ret) &&
-        isMinimalBlock(ret) &&
-        ret.style === 'blockquote'
-      ) {
-        ret.children.forEach((child, index) => {
-          if (isMinimalSpan(child) && child.text === '\r') {
-            child.text = '\n'
-            if (index === 0 || index === ret.children.length - 1) {
-              ret.children.splice(index, 1)
-            }
-          }
-        })
-      }
-      break
-    }
-
-    return node || next(element.childNodes) || []
-  }
-
-  /**
-   * Deserialize a `__decorator` type
-   * (an internal made up type to process decorators exclusively)
-   *
-   * @param decorator -
-   * @returns array of ...
-   */
-  deserializeDecorator = (decorator: PlaceholderDecorator): TypedObject[] => {
-    const {name} = decorator
-    const applyDecorator = (node: TypedObject) => {
-      if (isPlaceholderDecorator(node)) {
-        return this.deserializeDecorator(node)
-      } else if (isMinimalSpan(node)) {
-        node.marks = node.marks || []
-        if (node.text.trim()) {
-          // Only apply marks if this is an actual text
-          node.marks.unshift(name)
-        }
-      } else if (
-        'children' in node &&
-        Array.isArray((node as PortableTextBlock).children)
-      ) {
-        const block = node as any
-        block.children = block.children.map(applyDecorator)
-      }
-      return node
-    }
-    return decorator.children.reduce((children, node) => {
-      const ret = applyDecorator(node)
-      if (Array.isArray(ret)) {
-        return children.concat(ret)
-      }
-      children.push(ret)
-      return children
-    }, [] as TypedObject[])
-  }
-
-  /**
-   * Deserialize a `__annotation` object.
-   * (an internal made up type to process annotations exclusively)
-   *
-   * @param annotation -
-   * @returns Array of...
-   */
-  deserializeAnnotation = (
-    annotation: PlaceholderAnnotation,
-  ): TypedObject[] => {
-    const {markDef} = annotation
-    this._markDefs.push(markDef)
-    const applyAnnotation = (node: TypedObject) => {
-      if (isPlaceholderAnnotation(node)) {
-        return this.deserializeAnnotation(node)
-      } else if (isMinimalSpan(node)) {
-        node.marks = node.marks || []
-        if (node.text.trim()) {
-          // Only apply marks if this is an actual text
-          node.marks.unshift(markDef._key)
-        }
-      } else if (
-        'children' in node &&
-        Array.isArray((node as PortableTextBlock).children)
-      ) {
-        const block = node as any
-        block.children = block.children.map(applyAnnotation)
-      }
-      return node
-    }
-    return annotation.children.reduce((children, node) => {
-      const ret = applyAnnotation(node)
-      if (Array.isArray(ret)) {
-        return children.concat(ret)
-      }
-      children.push(ret)
-      return children
-    }, [] as TypedObject[])
-  }
-}

package/src/HtmlDeserializer/preprocessors/index.ts

@@ -1,15 +0,0 @@
-import {preprocessWordOnline} from '../word-online/preprocessor.word-online'
-import {preprocessGDocs} from './preprocessor.gdocs'
-import {preprocessHTML} from './preprocessor.html'
-import {preprocessNotion} from './preprocessor.notion'
-import {preprocessWhitespace} from './preprocessor.whitespace'
-import {preprocessWord} from './preprocessor.word'
-
-export const preprocessors = [
-  preprocessWhitespace,
-  preprocessNotion,
-  preprocessWord,
-  preprocessWordOnline,
-  preprocessGDocs,
-  preprocessHTML,
-]

package/src/HtmlDeserializer/preprocessors/preprocessor.gdocs.ts

@@ -1,66 +0,0 @@
-import {tagName} from '../helpers'
-import {_XPathResult} from './xpathResult'
-
-export function preprocessGDocs(_html: string, doc: Document): Document {
-  let gDocsRootOrSiblingNode = doc
-    .evaluate(
-      '//*[@id and contains(@id, "docs-internal-guid")]',
-      doc,
-      null,
-      _XPathResult.ORDERED_NODE_ITERATOR_TYPE,
-      null,
-    )
-    .iterateNext()
-
-  if (gDocsRootOrSiblingNode) {
-    const isWrappedRootTag = tagName(gDocsRootOrSiblingNode) === 'b'
-
-    // If this document isn't wrapped in a 'b' tag, then assume all siblings live on the root level
-    if (!isWrappedRootTag) {
-      gDocsRootOrSiblingNode = doc.body
-    }
-
-    // Tag every child with attribute 'is-google-docs' so that the GDocs rule-set can
-    // work exclusivly on these children
-    const childNodes = doc.evaluate(
-      '//*',
-      doc,
-      null,
-      _XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-      null,
-    )
-
-    for (let i = childNodes.snapshotLength - 1; i >= 0; i--) {
-      const elm = childNodes.snapshotItem(i) as HTMLElement
-      elm?.setAttribute('data-is-google-docs', 'true')
-
-      if (
-        elm?.parentElement === gDocsRootOrSiblingNode ||
-        (!isWrappedRootTag && elm.parentElement === doc.body)
-      ) {
-        elm?.setAttribute('data-is-root-node', 'true')
-        tagName(elm)
-      }
-
-      // Handle checkmark lists - The first child of a list item is an image with a checkmark, and the serializer
-      // expects the first child to be the text node
-      if (
-        tagName(elm) === 'li' &&
-        elm.firstChild &&
-        tagName(elm?.firstChild) === 'img'
-      ) {
-        elm.removeChild(elm.firstChild)
-      }
-    }
-
-    // Remove that 'b' which Google Docs wraps the HTML content in
-    if (isWrappedRootTag) {
-      doc.body.firstElementChild?.replaceWith(
-        ...Array.from(gDocsRootOrSiblingNode.childNodes),
-      )
-    }
-
-    return doc
-  }
-  return doc
-}

package/src/HtmlDeserializer/preprocessors/preprocessor.html.ts

@@ -1,57 +0,0 @@
-import {_XPathResult} from './xpathResult'
-
-// Remove this cruft from the document
-const unwantedWordDocumentPaths = [
-  '/html/text()',
-  '/html/head/text()',
-  '/html/body/text()',
-  '/html/body/ul/text()',
-  '/html/body/ol/text()',
-  '//comment()',
-  '//style',
-  '//xml',
-  '//script',
-  '//meta',
-  '//link',
-]
-
-export function preprocessHTML(_html: string, doc: Document): Document {
-  // Make sure text directly on the body is wrapped in spans.
-  // This mimics what the browser does before putting html on the clipboard,
-  // when used in a script context with JSDOM
-  const bodyTextNodes = doc.evaluate(
-    '/html/body/text()',
-    doc,
-    null,
-    _XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-    null,
-  )
-
-  for (let i = bodyTextNodes.snapshotLength - 1; i >= 0; i--) {
-    const node = bodyTextNodes.snapshotItem(i) as HTMLElement
-    const text = node.textContent || ''
-    if (text.replace(/[^\S\n]+$/g, '')) {
-      const newNode = doc.createElement('span')
-      newNode.appendChild(doc.createTextNode(text))
-      node.parentNode?.replaceChild(newNode, node)
-    } else {
-      node.parentNode?.removeChild(node)
-    }
-  }
-
-  const unwantedNodes = doc.evaluate(
-    unwantedWordDocumentPaths.join('|'),
-    doc,
-    null,
-    _XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-    null,
-  )
-  for (let i = unwantedNodes.snapshotLength - 1; i >= 0; i--) {
-    const unwanted = unwantedNodes.snapshotItem(i)
-    if (!unwanted) {
-      continue
-    }
-    unwanted.parentNode?.removeChild(unwanted)
-  }
-  return doc
-}

package/src/HtmlDeserializer/preprocessors/preprocessor.notion.ts

@@ -1,25 +0,0 @@
-import {_XPathResult} from './xpathResult'
-
-export function preprocessNotion(html: string, doc: Document): Document {
-  const NOTION_REGEX = /<!-- notionvc:.*?-->/g
-
-  if (html.match(NOTION_REGEX)) {
-    // Tag every child with attribute 'is-notion' so that the Notion rule-set can
-    // work exclusivly on these children
-    const childNodes = doc.evaluate(
-      '//*',
-      doc,
-      null,
-      _XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-      null,
-    )
-
-    for (let i = childNodes.snapshotLength - 1; i >= 0; i--) {
-      const elm = childNodes.snapshotItem(i) as HTMLElement
-      elm?.setAttribute('data-is-notion', 'true')
-    }
-
-    return doc
-  }
-  return doc
-}

package/src/HtmlDeserializer/preprocessors/preprocessor.whitespace.ts

@@ -1,56 +0,0 @@
-import {PRESERVE_WHITESPACE_TAGS} from '../../constants'
-import {_XPathResult} from './xpathResult'
-
-// Elements that only contain block-level children (not inline text content)
-const BLOCK_CONTAINER_ELEMENTS = [
-  'body',
-  'table',
-  'tbody',
-  'thead',
-  'tfoot',
-  'tr',
-  'ul',
-  'ol',
-]
-
-export function preprocessWhitespace(_: string, doc: Document): Document {
-  // Recursively process all nodes.
-  function processNode(node: Node) {
-    // If this is a text node and not inside a tag where whitespace should be preserved, process it.
-    if (
-      node.nodeType === _XPathResult.BOOLEAN_TYPE &&
-      !PRESERVE_WHITESPACE_TAGS.includes(
-        node.parentElement?.tagName.toLowerCase() || '',
-      )
-    ) {
-      const normalized =
-        node.textContent
-          ?.replace(/\s\s+/g, ' ') // Remove multiple whitespace
-          .replace(/[\r\n]+/g, ' ') || '' // Replace newlines with spaces
-      const parentTag = node.parentElement?.tagName.toLowerCase()
-
-      if (
-        parentTag &&
-        BLOCK_CONTAINER_ELEMENTS.includes(parentTag) &&
-        normalized.trim() === ''
-      ) {
-        // If parent is a block container and text is only whitespace, remove it
-        node.parentNode?.removeChild(node)
-      } else {
-        node.textContent = normalized
-      }
-    }
-    // Otherwise, if this node has children, process them.
-    else {
-      // Process children in reverse to handle removals safely
-      for (let i = node.childNodes.length - 1; i >= 0; i--) {
-        processNode(node.childNodes[i])
-      }
-    }
-  }
-
-  // Process all nodes starting from the root.
-  processNode(doc.body)
-
-  return doc
-}

package/src/HtmlDeserializer/preprocessors/preprocessor.word.ts

@@ -1,92 +0,0 @@
-import {_XPathResult} from './xpathResult'
-
-const WORD_HTML_REGEX =
-  /(class="?Mso|style=(?:"|')[^"]*?\bmso-|w:WordDocument|<o:\w+>|<\/font>)/
-
-// xPaths for elements that will be removed from the document
-const unwantedPaths = [
-  '//o:p',
-  "//span[@style='mso-list:Ignore']",
-  "//span[@style='mso-list: Ignore']",
-]
-
-// xPaths for elements that needs to be remapped into other tags
-const mappedPaths = [
-  "//p[@class='MsoTocHeading']",
-  "//p[@class='MsoTitle']",
-  "//p[@class='MsoToaHeading']",
-  "//p[@class='MsoSubtitle']",
-  "//span[@class='MsoSubtleEmphasis']",
-  "//span[@class='MsoIntenseEmphasis']",
-]
-
-// Which HTML element(s) to map the elements matching mappedPaths into
-const elementMap: Record<string, string[] | undefined> = {
-  MsoTocHeading: ['h3'],
-  MsoTitle: ['h1'],
-  MsoToaHeading: ['h2'],
-  MsoSubtitle: ['h5'],
-  MsoSubtleEmphasis: ['span', 'em'],
-  MsoIntenseEmphasis: ['span', 'em', 'strong'],
-  // Remove cruft
-}
-
-function isWordHtml(html: string) {
-  return WORD_HTML_REGEX.test(html)
-}
-
-export function preprocessWord(html: string, doc: Document): Document {
-  if (!isWordHtml(html)) {
-    return doc
-  }
-
-  const unwantedNodes = doc.evaluate(
-    unwantedPaths.join('|'),
-    doc,
-    (prefix) => {
-      if (prefix === 'o') {
-        return 'urn:schemas-microsoft-com:office:office'
-      }
-      return null
-    },
-    _XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-    null,
-  )
-
-  for (let i = unwantedNodes.snapshotLength - 1; i >= 0; i--) {
-    const unwanted = unwantedNodes.snapshotItem(i)
-    if (unwanted?.parentNode) {
-      unwanted.parentNode.removeChild(unwanted)
-    }
-  }
-
-  // Transform mapped elements into what they should be mapped to
-  const mappedElements = doc.evaluate(
-    mappedPaths.join('|'),
-    doc,
-    null,
-    _XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-    null,
-  )
-  for (let i = mappedElements.snapshotLength - 1; i >= 0; i--) {
-    const mappedElm = mappedElements.snapshotItem(i) as HTMLElement
-    const tags = elementMap[mappedElm.className]
-    const text = doc.createTextNode(mappedElm.textContent || '')
-    if (!tags) {
-      continue
-    }
-
-    const parentElement = doc.createElement(tags[0])
-    let parent = parentElement
-    let child = parentElement
-    tags.slice(1).forEach((tag) => {
-      child = doc.createElement(tag)
-      parent.appendChild(child)
-      parent = child
-    })
-    child.appendChild(text)
-    mappedElm?.parentNode?.replaceChild(parentElement, mappedElm)
-  }
-
-  return doc
-}

package/src/HtmlDeserializer/preprocessors/xpathResult.ts

@@ -1,13 +0,0 @@
-// We need this here if run server side
-export const _XPathResult = {
-  ANY_TYPE: 0,
-  NUMBER_TYPE: 1,
-  STRING_TYPE: 2,
-  BOOLEAN_TYPE: 3,
-  UNORDERED_NODE_ITERATOR_TYPE: 4,
-  ORDERED_NODE_ITERATOR_TYPE: 5,
-  UNORDERED_NODE_SNAPSHOT_TYPE: 6,
-  ORDERED_NODE_SNAPSHOT_TYPE: 7,
-  ANY_UNORDERED_NODE_TYPE: 8,
-  FIRST_ORDERED_NODE_TYPE: 9,
-}

package/src/HtmlDeserializer/rules/index.ts

@@ -1,21 +0,0 @@
-import type {Schema} from '@portabletext/schema'
-import type {SchemaMatchers} from '../../schema-matchers'
-import type {DeserializerRule} from '../../types'
-import {createWordOnlineRules} from '../word-online/rules.word-online'
-import {createGDocsRules} from './rules.gdocs'
-import {createHTMLRules} from './rules.html'
-import {createNotionRules} from './rules.notion'
-import {createWordRules} from './rules.word'
-
-export function createRules(
-  schema: Schema,
-  options: {keyGenerator?: () => string; matchers?: SchemaMatchers},
-): DeserializerRule[] {
-  return [
-    ...createWordRules(),
-    ...createWordOnlineRules(schema, options),
-    ...createNotionRules(),
-    ...createGDocsRules(schema),
-    ...createHTMLRules(schema, options),
-  ]
-}