@portabletext/block-tools 2.0.8 → 3.1.0

package/src/HtmlDeserializer/index.ts

@@ -1,9 +1,4 @@
-import type {
-  ArraySchemaType,
-  PortableTextBlock,
-  PortableTextObject,
-  PortableTextTextBlock,
-} from '@sanity/types'
+import type {Schema} from '@portabletext/schema'
 import {flatten} from 'lodash'
 import type {
   ArbitraryTypedObject,
@@ -13,10 +8,13 @@ import type {
   PlaceholderDecorator,
   TypedObject,
 } from '../types'
-import {findBlockType} from '../util/findBlockType'
+import {
+  isTextBlock,
+  type PortableTextBlock,
+  type PortableTextObject,
+} from '../types.portable-text'
 import {resolveJsType} from '../util/resolveJsType'
 import {
-  createRuleOptions,
   defaultParseHtml,
   ensureRootIsBlocks,
   flattenNestedBlocks,
@@ -36,7 +34,7 @@ import {createRules} from './rules'
  *
  */
 export default class HtmlDeserializer {
-  blockContentType: ArraySchemaType
+  schema: Schema
   rules: DeserializerRule[]
   parseHtml: (html: string) => HTMLElement
   _markDefs: PortableTextObject[] = []
@@ -47,21 +45,14 @@ export default class HtmlDeserializer {
    * @param blockContentType - Schema type for array containing _at least_ a block child type
    * @param options - Options for the deserialization process
    */
-  constructor(
-    blockContentType: ArraySchemaType,
-    options: HtmlDeserializerOptions = {},
-  ) {
+  constructor(schema: Schema, options: HtmlDeserializerOptions = {}) {
     const {rules = [], unstable_whitespaceOnPasteMode = 'preserve'} = options
-    if (!blockContentType) {
-      throw new Error("Parameter 'blockContentType' is required")
-    }
-    const standardRules = createRules(blockContentType, {
-      ...createRuleOptions(blockContentType),
+    const standardRules = createRules(schema, {
       keyGenerator: options.keyGenerator,
     })
+    this.schema = schema
     this.rules = [...rules, ...standardRules]
     const parseHtml = options.parseHtml || defaultParseHtml()
-    this.blockContentType = blockContentType
     this.parseHtml = (html) => {
       const doc = preprocess(html, parseHtml, {unstable_whitespaceOnPasteMode})
       return doc.body
@@ -81,16 +72,16 @@ export default class HtmlDeserializer {
     const children = Array.from(fragment.childNodes) as HTMLElement[]
     // Ensure that there are no blocks within blocks, and trim whitespace
     const blocks = trimWhitespace(
+      this.schema,
       flattenNestedBlocks(
-        ensureRootIsBlocks(this.deserializeElements(children)),
+        this.schema,
+        ensureRootIsBlocks(this.schema, this.deserializeElements(children)),
       ),
     )
 
     if (this._markDefs.length > 0) {
       blocks
-        .filter(
-          (block): block is PortableTextTextBlock => block._type === 'block',
-        )
+        .filter((block) => isTextBlock(this.schema, block))
         .forEach((block) => {
           block.markDefs = block.markDefs || []
           block.markDefs = block.markDefs.concat(
@@ -103,15 +94,9 @@ export default class HtmlDeserializer {
         })
     }
 
-    // Set back the potentially hoisted block type
-    const type = this.blockContentType.of.find(findBlockType)
-    if (!type) {
-      return blocks
-    }
-
     return blocks.map((block) => {
       if (block._type === 'block') {
-        block._type = type.name
+        block._type = this.schema.block.name
       }
       return block
     })

package/src/HtmlDeserializer/rules/gdocs.ts

@@ -1,4 +1,4 @@
-import type {ArraySchemaType} from '@sanity/types'
+import type {Schema} from '@portabletext/schema'
 import {
   BLOCK_DEFAULT_STYLE,
   DEFAULT_BLOCK,
@@ -7,7 +7,7 @@ import {
   HTML_HEADER_TAGS,
   HTML_LIST_CONTAINER_TAGS,
 } from '../../constants'
-import type {BlockEnabledFeatures, DeserializerRule} from '../../types'
+import type {DeserializerRule} from '../../types'
 import {isElement, tagName} from '../helpers'
 
 const LIST_CONTAINER_TAGS = Object.keys(HTML_LIST_CONTAINER_TAGS)
@@ -81,22 +81,19 @@ const blocks: Record<string, {style: string} | undefined> = {
   ...HTML_HEADER_TAGS,
 }
 
-function getBlockStyle(el: Node, enabledBlockStyles: string[]): string {
+function getBlockStyle(schema: Schema, el: Node): string {
   const childTag = tagName(el.firstChild)
   const block = childTag && blocks[childTag]
   if (!block) {
     return BLOCK_DEFAULT_STYLE
   }
-  if (!enabledBlockStyles.includes(block.style)) {
+  if (!schema.styles.some((style) => style.name === block.style)) {
     return BLOCK_DEFAULT_STYLE
   }
   return block.style
 }
 
-export default function createGDocsRules(
-  _blockContentType: ArraySchemaType,
-  options: BlockEnabledFeatures,
-): DeserializerRule[] {
+export default function createGDocsRules(schema: Schema): DeserializerRule[] {
   return [
     {
       deserialize(el) {
@@ -130,7 +127,7 @@ export default function createGDocsRules(
             ...DEFAULT_BLOCK,
             listItem: getListItemStyle(el),
             level: getListItemLevel(el),
-            style: getBlockStyle(el, options.enabledBlockStyles),
+            style: getBlockStyle(schema, el),
             children: next(el.firstChild?.childNodes || []),
           }
         }

package/src/HtmlDeserializer/rules/html.ts

@@ -1,4 +1,4 @@
-import type {ArraySchemaType, TypedObject} from '@sanity/types'
+import type {Schema} from '@portabletext/schema'
 import {
   DEFAULT_BLOCK,
   DEFAULT_SPAN,
@@ -10,27 +10,33 @@ import {
   HTML_SPAN_TAGS,
   type PartialBlock,
 } from '../../constants'
-import type {BlockEnabledFeatures, DeserializerRule} from '../../types'
+import type {DeserializerRule} from '../../types'
 import {keyGenerator} from '../../util/randomKey'
 import {isElement, tagName} from '../helpers'
 import {whitespaceTextNodeRule} from './whitespace-text-node'
 
 export function resolveListItem(
+  schema: Schema,
   listNodeTagName: string,
-  enabledListTypes: string[],
 ): string | undefined {
-  if (listNodeTagName === 'ul' && enabledListTypes.includes('bullet')) {
+  if (
+    listNodeTagName === 'ul' &&
+    schema.lists.some((list) => list.name === 'bullet')
+  ) {
     return 'bullet'
   }
-  if (listNodeTagName === 'ol' && enabledListTypes.includes('number')) {
+  if (
+    listNodeTagName === 'ol' &&
+    schema.lists.some((list) => list.name === 'number')
+  ) {
     return 'number'
   }
   return undefined
 }
 
 export default function createHTMLRules(
-  _blockContentType: ArraySchemaType,
-  options: BlockEnabledFeatures & {keyGenerator?: () => string},
+  schema: Schema,
+  options: {keyGenerator?: () => string},
 ): DeserializerRule[] {
   return [
     whitespaceTextNodeRule,
@@ -41,7 +47,9 @@ export default function createHTMLRules(
           return undefined
         }
 
-        const isCodeEnabled = options.enabledBlockStyles.includes('code')
+        const isCodeEnabled = schema.styles.some(
+          (style) => style.name === 'code',
+        )
 
         return {
           _type: 'block',
@@ -134,8 +142,9 @@ export default function createHTMLRules(
         if (el.parentNode && tagName(el.parentNode) === 'li') {
           return next(el.childNodes)
         }
+        const blockStyle = block.style
         // If style is not supported, return a defaultBlockType
-        if (!options.enabledBlockStyles.includes(block.style)) {
+        if (!schema.styles.some((style) => style.name === blockStyle)) {
           block = DEFAULT_BLOCK
         }
         return {
@@ -194,10 +203,7 @@ export default function createHTMLRules(
         ) {
           return undefined
         }
-        const enabledListItem = resolveListItem(
-          parentTag,
-          options.enabledListTypes,
-        )
+        const enabledListItem = resolveListItem(schema, parentTag)
         // If the list item style is not supported, return a new default block
         if (!enabledListItem) {
           return block({_type: 'block', children: next(el.childNodes)})
@@ -212,7 +218,12 @@ export default function createHTMLRules(
     {
       deserialize(el, next) {
         const decorator = HTML_DECORATOR_TAGS[tagName(el) || '']
-        if (!decorator || !options.enabledSpanDecorators.includes(decorator)) {
+        if (
+          !decorator ||
+          !schema.decorators.some(
+            (decoratorType) => decoratorType.name === decorator,
+          )
+        ) {
           return undefined
         }
         return {
@@ -228,23 +239,23 @@ export default function createHTMLRules(
         if (tagName(el) !== 'a') {
           return undefined
         }
-        const linkEnabled = options.enabledBlockAnnotations.includes('link')
+        const linkEnabled = schema.annotations.some(
+          (annotation) => annotation.name === 'link',
+        )
         const href = isElement(el) && el.getAttribute('href')
         if (!href) {
           return next(el.childNodes)
         }
-        let markDef: TypedObject | undefined
         if (linkEnabled) {
-          markDef = {
-            _key: options.keyGenerator
-              ? options.keyGenerator()
-              : keyGenerator(),
-            _type: 'link',
-            href: href,
-          }
           return {
             _type: '__annotation',
-            markDef: markDef,
+            markDef: {
+              _key: options.keyGenerator
+                ? options.keyGenerator()
+                : keyGenerator(),
+              _type: 'link',
+              href: href,
+            },
             children: next(el.childNodes),
           }
         }

package/src/HtmlDeserializer/rules/index.ts

@@ -1,18 +1,18 @@
-import type {ArraySchemaType} from '@sanity/types'
-import type {BlockEnabledFeatures, DeserializerRule} from '../../types'
+import type {Schema} from '@portabletext/schema'
+import type {DeserializerRule} from '../../types'
 import createGDocsRules from './gdocs'
 import createHTMLRules from './html'
 import createNotionRules from './notion'
 import createWordRules from './word'
 
 export function createRules(
-  blockContentType: ArraySchemaType,
-  options: BlockEnabledFeatures & {keyGenerator?: () => string},
+  schema: Schema,
+  options: {keyGenerator?: () => string},
 ): DeserializerRule[] {
   return [
     ...createWordRules(),
-    ...createNotionRules(blockContentType),
-    ...createGDocsRules(blockContentType, options),
-    ...createHTMLRules(blockContentType, options),
+    ...createNotionRules(),
+    ...createGDocsRules(schema),
+    ...createHTMLRules(schema, options),
   ]
 }

package/src/HtmlDeserializer/rules/notion.ts

@@ -1,4 +1,3 @@
-import type {ArraySchemaType} from '@sanity/types'
 import {DEFAULT_SPAN} from '../../constants'
 import type {DeserializerRule} from '../../types'
 import {isElement, tagName} from '../helpers'
@@ -28,9 +27,7 @@ function isNotion(el: Node): boolean {
   return isElement(el) && Boolean(el.getAttribute('data-is-notion'))
 }
 
-export default function createNotionRules(
-  _blockContentType: ArraySchemaType,
-): DeserializerRule[] {
+export default function createNotionRules(): DeserializerRule[] {
   return [
     {
       deserialize(el) {

package/src/index.ts

@@ -1,54 +1,49 @@
-import type {ArraySchemaType, PortableTextTextBlock} from '@sanity/types'
+import {sanitySchemaToPortableTextSchema} from '@portabletext/sanity-bridge'
+import type {Schema} from '@portabletext/schema'
+import type {ArraySchemaType} from '@sanity/types'
 import HtmlDeserializer from './HtmlDeserializer'
-import type {
-  BlockContentFeatures,
-  HtmlDeserializerOptions,
-  TypedObject,
-} from './types'
-import blockContentTypeFeatures from './util/blockContentTypeFeatures'
+import type {HtmlDeserializerOptions, TypedObject} from './types'
+import type {PortableTextTextBlock} from './types.portable-text'
 import {normalizeBlock} from './util/normalizeBlock'
 
 /**
  * Convert HTML to blocks respecting the block content type's schema
  *
  * @param html - The HTML to convert to blocks
- * @param blockContentType - A compiled version of the schema type for the block content
+ * @param schemaType - A compiled version of the schema type for the block content
  * @param options - Options for deserializing HTML to blocks
  * @returns Array of blocks
  * @public
  */
 export function htmlToBlocks(
   html: string,
-  blockContentType: ArraySchemaType,
+  schemaType: ArraySchemaType | Schema,
   options: HtmlDeserializerOptions = {},
 ): (TypedObject | PortableTextTextBlock)[] {
-  const deserializer = new HtmlDeserializer(blockContentType, options)
+  const schema = isSanitySchema(schemaType)
+    ? sanitySchemaToPortableTextSchema(schemaType)
+    : schemaType
+
+  const deserializer = new HtmlDeserializer(schema, options)
   return deserializer
     .deserialize(html)
     .map((block) => normalizeBlock(block, {keyGenerator: options.keyGenerator}))
 }
 
-/**
- * Normalize and extract features of an schema type containing a block type
- *
- * @param blockContentType - Schema type for the block type
- * @returns Returns the featureset of a compiled block content type.
- * @public
- */
-export function getBlockContentFeatures(
-  blockContentType: ArraySchemaType,
-): BlockContentFeatures {
-  return blockContentTypeFeatures(blockContentType)
-}
-
+export type {ArbitraryTypedObject, DeserializerRule, HtmlParser} from './types'
 export type {
-  ArbitraryTypedObject,
-  BlockEditorSchemaProps,
-  DeserializerRule,
-  HtmlParser,
-  ResolvedAnnotationType,
-} from './types'
+  PortableTextBlock,
+  PortableTextObject,
+  PortableTextSpan,
+  PortableTextTextBlock,
+} from './types.portable-text'
 export type {BlockNormalizationOptions} from './util/normalizeBlock'
 export {randomKey} from './util/randomKey'
 export {normalizeBlock}
-export type {BlockContentFeatures, HtmlDeserializerOptions, TypedObject}
+export type {HtmlDeserializerOptions, TypedObject}
+
+function isSanitySchema(
+  schema: ArraySchemaType | Schema,
+): schema is ArraySchemaType {
+  return schema.hasOwnProperty('jsonType')
+}

package/src/types.portable-text.ts

@@ -0,0 +1,79 @@
+import type {Schema} from '@portabletext/schema'
+import {isArbitraryTypedObject} from './types'
+
+/**
+ * @public
+ */
+export type PortableTextBlock = PortableTextTextBlock | PortableTextObject
+
+/**
+ * @public
+ */
+export interface PortableTextTextBlock<
+  TChild = PortableTextSpan | PortableTextObject,
+> {
+  _type: string
+  _key: string
+  children: TChild[]
+  markDefs?: PortableTextObject[]
+  listItem?: string
+  style?: string
+  level?: number
+}
+
+export function isTextBlock(
+  schema: Schema,
+  block: unknown,
+): block is PortableTextTextBlock {
+  if (!isArbitraryTypedObject(block)) {
+    return false
+  }
+
+  if (block._type !== schema.block.name) {
+    return false
+  }
+
+  if (!Array.isArray(block.children)) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * @public
+ */
+export interface PortableTextSpan {
+  _key: string
+  _type: 'span'
+  text: string
+  marks?: string[]
+}
+
+export function isSpan(
+  schema: Schema,
+  child: unknown,
+): child is PortableTextSpan {
+  if (!isArbitraryTypedObject(child)) {
+    return false
+  }
+
+  if (child._type !== schema.span.name) {
+    return false
+  }
+
+  if (typeof child.text !== 'string') {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * @public
+ */
+export interface PortableTextObject {
+  _type: string
+  _key: string
+  [other: string]: unknown
+}

package/src/types.ts

@@ -1,47 +1,4 @@
-import type {
-  ArraySchemaType,
-  I18nTitledListValue,
-  ObjectSchemaType,
-  PortableTextObject,
-  SpanSchemaType,
-  TitledListValue,
-} from '@sanity/types'
-import type {ComponentType} from 'react'
-
-/**
- * @public
- */
-export interface BlockContentFeatures {
-  styles: TitledListValue<string>[]
-  decorators: TitledListValue<string>[]
-  annotations: ResolvedAnnotationType[]
-  lists: I18nTitledListValue<string>[]
-  types: {
-    block: ArraySchemaType
-    span: SpanSchemaType
-    inlineObjects: ObjectSchemaType[]
-    blockObjects: ObjectSchemaType[]
-  }
-}
-
-/**
- * @beta
- */
-export interface BlockEditorSchemaProps {
-  icon?: string | ComponentType
-  render?: ComponentType
-}
-
-/**
- * @public
- */
-export interface ResolvedAnnotationType {
-  blockEditor?: BlockEditorSchemaProps
-  title: string | undefined
-  value: string
-  type: ObjectSchemaType
-  icon: ComponentType | undefined
-}
+import type {PortableTextObject} from './types.portable-text'
 
 /**
  * @public
@@ -58,6 +15,16 @@ export interface ArbitraryTypedObject extends TypedObject {
   [key: string]: unknown
 }
 
+export function isArbitraryTypedObject(
+  object: unknown,
+): object is ArbitraryTypedObject {
+  return isRecord(object) && typeof object._type === 'string'
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && (typeof value === 'object' || typeof value === 'function')
+}
+
 export interface MinimalSpan {
   _type: 'span'
   _key?: string
@@ -106,9 +73,6 @@ export interface HtmlDeserializerOptions {
   unstable_whitespaceOnPasteMode?: WhiteSpacePasteMode
 }
 
-/**
- * @public
- */
 export interface HtmlPreprocessorOptions {
   unstable_whitespaceOnPasteMode?: WhiteSpacePasteMode
 }
@@ -128,13 +92,3 @@ export interface DeserializerRule {
     },
   ) => TypedObject | TypedObject[] | undefined
 }
-
-/**
- * @public
- */
-export interface BlockEnabledFeatures {
-  enabledBlockStyles: string[]
-  enabledSpanDecorators: string[]
-  enabledListTypes: string[]
-  enabledBlockAnnotations: string[]
-}

package/src/util/normalizeBlock.ts

@@ -1,10 +1,11 @@
+import type {Schema} from '@portabletext/schema'
+import {isEqual} from 'lodash'
+import type {TypedObject} from '../types'
 import {
-  isPortableTextSpan,
+  isSpan,
   type PortableTextSpan,
   type PortableTextTextBlock,
-} from '@sanity/types'
-import {isEqual} from 'lodash'
-import type {TypedObject} from '../types'
+} from '../types.portable-text'
 import {keyGenerator} from './randomKey'
 
 /**
@@ -53,6 +54,21 @@ export function normalizeBlock(
 > & {
   _key: string
 } {
+  const schema: Schema = {
+    block: {
+      name: options.blockTypeName || 'block',
+    },
+    span: {
+      name: 'span',
+    },
+    styles: [],
+    lists: [],
+    decorators: [],
+    annotations: [],
+    blockObjects: [],
+    inlineObjects: [],
+  }
+
   if (node._type !== (options.blockTypeName || 'block')) {
     return '_key' in node
       ? (node as TypedObject & {_key: string})
@@ -99,8 +115,8 @@ export function normalizeBlock(
         const previousChild = acc[acc.length - 1]
         if (
           previousChild &&
-          isPortableTextSpan(child) &&
-          isPortableTextSpan(previousChild) &&
+          isSpan(schema, child) &&
+          isSpan(schema, previousChild) &&
           isEqual(previousChild.marks, child.marks)
         ) {
           if (
@@ -129,7 +145,7 @@ export function normalizeBlock(
         ? options.keyGenerator()
         : keyGenerator()
 
-      if (isPortableTextSpan(child)) {
+      if (isSpan(schema, child)) {
         if (!child.marks) {
           child.marks = []
         } else if (allowedDecorators) {