@portabletext/block-tools 3.0.0 → 3.2.0

package/src/HtmlDeserializer/helpers.ts

@@ -1,3 +1,4 @@
+import type {Schema} from '@portabletext/schema'
 import {vercelStegaClean} from '@vercel/stega'
 import {isEqual} from 'lodash'
 import {DEFAULT_BLOCK} from '../constants'
@@ -15,7 +16,6 @@ import {
   type PortableTextObject,
   type PortableTextTextBlock,
 } from '../types.portable-text'
-import type {PortableTextSchema} from '../util/portable-text-schema'
 import {resolveJsType} from '../util/resolveJsType'
 import preprocessors from './preprocessors'
 
@@ -70,7 +70,7 @@ export function defaultParseHtml(): HtmlParser {
 }
 
 export function flattenNestedBlocks(
-  schema: PortableTextSchema,
+  schema: Schema,
   blocks: TypedObject[],
 ): TypedObject[] {
   let depth = 0
@@ -124,7 +124,7 @@ function isWhiteSpaceChar(text: string) {
  * @returns
  */
 export function trimWhitespace(
-  schema: PortableTextSchema,
+  schema: Schema,
   blocks: TypedObject[],
 ): TypedObject[] {
   blocks.forEach((block) => {
@@ -186,7 +186,7 @@ export function trimWhitespace(
 }
 
 export function ensureRootIsBlocks(
-  schema: PortableTextSchema,
+  schema: Schema,
   blocks: TypedObject[],
 ): TypedObject[] {
   return blocks.reduce((memo, node, i, original) => {

package/src/HtmlDeserializer/index.ts

@@ -1,3 +1,4 @@
+import type {Schema} from '@portabletext/schema'
 import {flatten} from 'lodash'
 import type {
   ArbitraryTypedObject,
@@ -12,7 +13,6 @@ import {
   type PortableTextBlock,
   type PortableTextObject,
 } from '../types.portable-text'
-import type {PortableTextSchema} from '../util/portable-text-schema'
 import {resolveJsType} from '../util/resolveJsType'
 import {
   defaultParseHtml,
@@ -34,7 +34,7 @@ import {createRules} from './rules'
  *
  */
 export default class HtmlDeserializer {
-  schema: PortableTextSchema
+  schema: Schema
   rules: DeserializerRule[]
   parseHtml: (html: string) => HTMLElement
   _markDefs: PortableTextObject[] = []
@@ -45,10 +45,7 @@ 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(
-    schema: PortableTextSchema,
-    options: HtmlDeserializerOptions = {},
-  ) {
+  constructor(schema: Schema, options: HtmlDeserializerOptions = {}) {
     const {rules = [], unstable_whitespaceOnPasteMode = 'preserve'} = options
     const standardRules = createRules(schema, {
       keyGenerator: options.keyGenerator,

package/src/HtmlDeserializer/rules/gdocs.ts

@@ -1,3 +1,4 @@
+import type {Schema} from '@portabletext/schema'
 import {
   BLOCK_DEFAULT_STYLE,
   DEFAULT_BLOCK,
@@ -7,7 +8,6 @@ import {
   HTML_LIST_CONTAINER_TAGS,
 } from '../../constants'
 import type {DeserializerRule} from '../../types'
-import type {PortableTextSchema} from '../../util/portable-text-schema'
 import {isElement, tagName} from '../helpers'
 
 const LIST_CONTAINER_TAGS = Object.keys(HTML_LIST_CONTAINER_TAGS)
@@ -81,7 +81,7 @@ const blocks: Record<string, {style: string} | undefined> = {
   ...HTML_HEADER_TAGS,
 }
 
-function getBlockStyle(schema: PortableTextSchema, el: Node): string {
+function getBlockStyle(schema: Schema, el: Node): string {
   const childTag = tagName(el.firstChild)
   const block = childTag && blocks[childTag]
   if (!block) {
@@ -93,9 +93,7 @@ function getBlockStyle(schema: PortableTextSchema, el: Node): string {
   return block.style
 }
 
-export default function createGDocsRules(
-  schema: PortableTextSchema,
-): DeserializerRule[] {
+export default function createGDocsRules(schema: Schema): DeserializerRule[] {
   return [
     {
       deserialize(el) {

package/src/HtmlDeserializer/rules/html.ts

@@ -1,3 +1,4 @@
+import type {Schema} from '@portabletext/schema'
 import {
   DEFAULT_BLOCK,
   DEFAULT_SPAN,
@@ -10,13 +11,12 @@ import {
   type PartialBlock,
 } from '../../constants'
 import type {DeserializerRule} from '../../types'
-import type {PortableTextSchema} from '../../util/portable-text-schema'
 import {keyGenerator} from '../../util/randomKey'
 import {isElement, tagName} from '../helpers'
 import {whitespaceTextNodeRule} from './whitespace-text-node'
 
 export function resolveListItem(
-  schema: PortableTextSchema,
+  schema: Schema,
   listNodeTagName: string,
 ): string | undefined {
   if (
@@ -35,7 +35,7 @@ export function resolveListItem(
 }
 
 export default function createHTMLRules(
-  schema: PortableTextSchema,
+  schema: Schema,
   options: {keyGenerator?: () => string},
 ): DeserializerRule[] {
   return [

package/src/HtmlDeserializer/rules/index.ts

@@ -1,12 +1,12 @@
+import type {Schema} from '@portabletext/schema'
 import type {DeserializerRule} from '../../types'
-import type {PortableTextSchema} from '../../util/portable-text-schema'
 import createGDocsRules from './gdocs'
 import createHTMLRules from './html'
 import createNotionRules from './notion'
 import createWordRules from './word'
 
 export function createRules(
-  schema: PortableTextSchema,
+  schema: Schema,
   options: {keyGenerator?: () => string},
 ): DeserializerRule[] {
   return [

package/src/index.ts

@@ -1,25 +1,29 @@
+import {sanitySchemaToPortableTextSchema} from '@portabletext/sanity-bridge'
+import type {Schema} from '@portabletext/schema'
 import type {ArraySchemaType} from '@sanity/types'
 import HtmlDeserializer from './HtmlDeserializer'
 import type {HtmlDeserializerOptions, TypedObject} from './types'
 import type {PortableTextTextBlock} from './types.portable-text'
 import {normalizeBlock} from './util/normalizeBlock'
-import {getPortableTextSchema} from './util/portable-text-schema'
 
 /**
  * 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 schema = getPortableTextSchema(blockContentType)
+  const schema = isSanitySchema(schemaType)
+    ? sanitySchemaToPortableTextSchema(schemaType)
+    : schemaType
+
   const deserializer = new HtmlDeserializer(schema, options)
   return deserializer
     .deserialize(html)
@@ -37,3 +41,9 @@ export type {BlockNormalizationOptions} from './util/normalizeBlock'
 export {randomKey} from './util/randomKey'
 export {normalizeBlock}
 export type {HtmlDeserializerOptions, TypedObject}
+
+function isSanitySchema(
+  schema: ArraySchemaType | Schema,
+): schema is ArraySchemaType {
+  return schema.hasOwnProperty('jsonType')
+}

package/src/types.portable-text.ts

@@ -1,5 +1,5 @@
+import type {Schema} from '@portabletext/schema'
 import {isArbitraryTypedObject} from './types'
-import type {PortableTextSchema} from './util/portable-text-schema'
 
 /**
  * @public
@@ -22,7 +22,7 @@ export interface PortableTextTextBlock<
 }
 
 export function isTextBlock(
-  schema: PortableTextSchema,
+  schema: Schema,
   block: unknown,
 ): block is PortableTextTextBlock {
   if (!isArbitraryTypedObject(block)) {
@@ -51,7 +51,7 @@ export interface PortableTextSpan {
 }
 
 export function isSpan(
-  schema: PortableTextSchema,
+  schema: Schema,
   child: unknown,
 ): child is PortableTextSpan {
   if (!isArbitraryTypedObject(child)) {

package/src/util/normalizeBlock.ts

@@ -1,3 +1,4 @@
+import type {Schema} from '@portabletext/schema'
 import {isEqual} from 'lodash'
 import type {TypedObject} from '../types'
 import {
@@ -5,7 +6,6 @@ import {
   type PortableTextSpan,
   type PortableTextTextBlock,
 } from '../types.portable-text'
-import type {PortableTextSchema} from './portable-text-schema'
 import {keyGenerator} from './randomKey'
 
 /**
@@ -54,7 +54,7 @@ export function normalizeBlock(
 > & {
   _key: string
 } {
-  const schema: PortableTextSchema = {
+  const schema: Schema = {
     block: {
       name: options.blockTypeName || 'block',
     },
@@ -65,6 +65,8 @@ export function normalizeBlock(
     lists: [],
     decorators: [],
     annotations: [],
+    blockObjects: [],
+    inlineObjects: [],
   }
 
   if (node._type !== (options.blockTypeName || 'block')) {

package/src/util/portable-text-schema.ts

@@ -1,174 +0,0 @@
-import {
-  isBlockChildrenObjectField,
-  isBlockListObjectField,
-  isBlockSchemaType,
-  isBlockStyleObjectField,
-  isTitledListValue,
-  type ArraySchemaType,
-  type BlockSchemaType,
-  type EnumListProps,
-  type SpanSchemaType,
-} from '@sanity/types'
-import {findBlockType} from './findBlockType'
-
-export type PortableTextSchema = {
-  block: {
-    name: string
-  }
-  span: {
-    name: string
-  }
-  styles: ReadonlyArray<{
-    name: string
-    title?: string
-  }>
-  lists: ReadonlyArray<{
-    name: string
-    title?: string
-  }>
-  decorators: ReadonlyArray<{
-    name: string
-    title?: string
-  }>
-  annotations: ReadonlyArray<{
-    name: string
-    title?: string
-  }>
-}
-
-export function getPortableTextSchema(
-  blockContentType: ArraySchemaType,
-): PortableTextSchema {
-  if (!blockContentType) {
-    throw new Error("Parameter 'blockContentType' required")
-  }
-
-  const blockType = blockContentType.of.find(findBlockType)
-  if (!isBlockSchemaType(blockType)) {
-    throw new Error("'block' type is not defined in this schema (required).")
-  }
-
-  const ofType = blockType.fields.find(isBlockChildrenObjectField)?.type?.of
-  if (!ofType) {
-    throw new Error('No `of` declaration found for blocks `children` field')
-  }
-
-  const spanType = ofType.find(
-    (member): member is SpanSchemaType => member.name === 'span',
-  )
-  if (!spanType) {
-    throw new Error(
-      'No `span` type found in `block` schema type `children` definition',
-    )
-  }
-
-  const blockName = blockContentType.of.find(findBlockType)?.name
-
-  if (!blockName) {
-    throw new Error('No `block` type found in schema type')
-  }
-
-  return {
-    styles: resolveEnabledStyles(blockType),
-    decorators: resolveEnabledDecorators(spanType),
-    annotations: resolveEnabledAnnotationTypes(spanType),
-    lists: resolveEnabledListItems(blockType),
-    block: {
-      name: blockName,
-    },
-    span: {
-      name: spanType.name,
-    },
-  }
-}
-
-function resolveEnabledStyles(blockType: BlockSchemaType): ReadonlyArray<{
-  name: string
-  title?: string
-}> {
-  const styleField = blockType.fields.find(isBlockStyleObjectField)
-  if (!styleField) {
-    throw new Error(
-      "A field with name 'style' is not defined in the block type (required).",
-    )
-  }
-
-  const textStyles = getTitledListValuesFromEnumListOptions(
-    styleField.type.options,
-  )
-  if (textStyles.length === 0) {
-    throw new Error(
-      'The style fields need at least one style ' +
-        "defined. I.e: {title: 'Normal', value: 'normal'}.",
-    )
-  }
-
-  return textStyles
-}
-
-function resolveEnabledAnnotationTypes(
-  spanType: SpanSchemaType,
-): ReadonlyArray<{
-  name: string
-  title?: string
-}> {
-  return spanType.annotations.map((annotation) => ({
-    name: annotation.name,
-    title: annotation.title,
-  }))
-}
-
-function resolveEnabledDecorators(spanType: SpanSchemaType): ReadonlyArray<{
-  name: string
-  title?: string
-}> {
-  return spanType.decorators.map((decorator) => ({
-    name: decorator.value,
-    title: decorator.title,
-  }))
-}
-
-function resolveEnabledListItems(blockType: BlockSchemaType): ReadonlyArray<{
-  name: string
-  title?: string
-}> {
-  const listField = blockType.fields.find(isBlockListObjectField)
-  if (!listField) {
-    throw new Error(
-      "A field with name 'list' is not defined in the block type (required).",
-    )
-  }
-
-  const listItems = getTitledListValuesFromEnumListOptions(
-    listField.type.options,
-  )
-  if (!listItems) {
-    throw new Error('The list field need at least to be an empty array')
-  }
-
-  return listItems
-}
-
-function getTitledListValuesFromEnumListOptions(
-  options: EnumListProps<string> | undefined,
-): ReadonlyArray<{
-  name: string
-  title?: string
-}> {
-  const list = options ? options.list : undefined
-  if (!Array.isArray(list)) {
-    return []
-  }
-
-  return list.map((item) => {
-    if (isTitledListValue(item)) {
-      return {
-        name: item.value ?? item.title,
-        title: item.title,
-      }
-    }
-    return {
-      name: item,
-    }
-  })
-}