@portabletext/block-tools 2.0.7 → 3.0.0

package/lib/index.d.ts

@@ -1,36 +1,36 @@
-import { ArraySchemaType, I18nTitledListValue, ObjectSchemaType, PortableTextSpan, PortableTextTextBlock, SpanSchemaType, TitledListValue } from "@sanity/types";
-import { ComponentType } from "react";
+import { ArraySchemaType } from "@sanity/types";
 /**
  * @public
  */
-interface BlockContentFeatures {
-  styles: TitledListValue<string>[];
-  decorators: TitledListValue<string>[];
-  annotations: ResolvedAnnotationType[];
-  lists: I18nTitledListValue<string>[];
-  types: {
-    block: ArraySchemaType;
-    span: SpanSchemaType;
-    inlineObjects: ObjectSchemaType[];
-    blockObjects: ObjectSchemaType[];
-  };
+type PortableTextBlock = PortableTextTextBlock | PortableTextObject;
+/**
+ * @public
+ */
+interface PortableTextTextBlock<TChild = PortableTextSpan | PortableTextObject> {
+  _type: string;
+  _key: string;
+  children: TChild[];
+  markDefs?: PortableTextObject[];
+  listItem?: string;
+  style?: string;
+  level?: number;
 }
 /**
- * @beta
+ * @public
  */
-interface BlockEditorSchemaProps {
-  icon?: string | ComponentType;
-  render?: ComponentType;
+interface PortableTextSpan {
+  _key: string;
+  _type: 'span';
+  text: string;
+  marks?: string[];
 }
 /**
  * @public
  */
-interface ResolvedAnnotationType {
-  blockEditor?: BlockEditorSchemaProps;
-  title: string | undefined;
-  value: string;
-  type: ObjectSchemaType;
-  icon: ComponentType | undefined;
+interface PortableTextObject {
+  _type: string;
+  _key: string;
+  [other: string]: unknown;
 }
 /**
  * @public
@@ -62,10 +62,6 @@ interface HtmlDeserializerOptions {
   parseHtml?: HtmlParser;
   unstable_whitespaceOnPasteMode?: WhiteSpacePasteMode;
 }
-/**
- * @public
- */
-
 /**
  * @public
  */
@@ -75,9 +71,6 @@ interface DeserializerRule {
     block: ArbitraryTypedObject;
   }) => TypedObject | TypedObject[] | undefined;
 }
-/**
- * @public
- */
 /**
  * Block normalization options
  *
@@ -133,12 +126,4 @@ declare function randomKey(length: number): string;
  * @public
  */
 declare function htmlToBlocks(html: string, blockContentType: ArraySchemaType, options?: HtmlDeserializerOptions): (TypedObject | PortableTextTextBlock)[];
-/**
- * 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
- */
-declare function getBlockContentFeatures(blockContentType: ArraySchemaType): BlockContentFeatures;
-export { type ArbitraryTypedObject, type BlockContentFeatures, type BlockEditorSchemaProps, type BlockNormalizationOptions, type DeserializerRule, type HtmlDeserializerOptions, type HtmlParser, type ResolvedAnnotationType, type TypedObject, getBlockContentFeatures, htmlToBlocks, normalizeBlock, randomKey };
+export { type ArbitraryTypedObject, type BlockNormalizationOptions, type DeserializerRule, type HtmlDeserializerOptions, type HtmlParser, type PortableTextBlock, type PortableTextObject, type PortableTextSpan, type PortableTextTextBlock, type TypedObject, htmlToBlocks, normalizeBlock, randomKey };

package/lib/index.js

@@ -1,10 +1,19 @@
 import flatten from "lodash/flatten.js";
-import { isBlockSchemaType, isBlockChildrenObjectField, isObjectSchemaType, isBlockListObjectField, isBlockStyleObjectField, isTitledListValue, isPortableTextTextBlock, isPortableTextSpan } from "@sanity/types";
 import isEqual from "lodash/isEqual.js";
 import uniq from "lodash/uniq.js";
 import getRandomValues from "get-random-values-esm";
-function findBlockType(type) {
-  return type.type ? findBlockType(type.type) : type.name === "block";
+import { isBlockSchemaType, isBlockChildrenObjectField, isBlockListObjectField, isBlockStyleObjectField, isTitledListValue } from "@sanity/types";
+function isArbitraryTypedObject(object) {
+  return isRecord(object) && typeof object._type == "string";
+}
+function isRecord(value) {
+  return !!value && (typeof value == "object" || typeof value == "function");
+}
+function isTextBlock(schema, block) {
+  return !(!isArbitraryTypedObject(block) || block._type !== schema.block.name || !Array.isArray(block.children));
+}
+function isSpan(schema, child) {
+  return !(!isArbitraryTypedObject(child) || child._type !== schema.span.name || typeof child.text != "string");
 }
 const objectToString = Object.prototype.toString;
 function resolveJsType(val) {
@@ -96,85 +105,6 @@ uniq(
 uniq(
   Object.values(HTML_DECORATOR_TAGS)
 );
-function blockContentFeatures(blockContentType) {
-  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.name === "span"
-  );
-  if (!spanType)
-    throw new Error(
-      "No `span` type found in `block` schema type `children` definition"
-    );
-  const inlineObjectTypes = ofType.filter(
-    (inlineType) => inlineType.name !== "span" && isObjectSchemaType(inlineType)
-  ), blockObjectTypes = blockContentType.of.filter(
-    (memberType) => memberType.name !== blockType.name && isObjectSchemaType(memberType)
-  );
-  return {
-    styles: resolveEnabledStyles(blockType),
-    decorators: resolveEnabledDecorators(spanType),
-    annotations: resolveEnabledAnnotationTypes(spanType),
-    lists: resolveEnabledListItems(blockType),
-    types: {
-      block: blockContentType,
-      span: spanType,
-      inlineObjects: inlineObjectTypes,
-      blockObjects: blockObjectTypes
-    }
-  };
-}
-function resolveEnabledStyles(blockType) {
-  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) {
-  return spanType.annotations.map((annotation) => ({
-    title: annotation.title,
-    type: annotation,
-    value: annotation.name,
-    icon: annotation.icon
-  }));
-}
-function resolveEnabledDecorators(spanType) {
-  return spanType.decorators;
-}
-function resolveEnabledListItems(blockType) {
-  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) {
-  const list = options ? options.list : void 0;
-  return Array.isArray(list) ? list.map(
-    (item) => isTitledListValue(item) ? item : { title: item, value: item }
-  ) : [];
-}
 const _XPathResult = {
   BOOLEAN_TYPE: 3,
   ORDERED_NODE_ITERATOR_TYPE: 5,
@@ -346,23 +276,6 @@ var preprocessWord = (html, doc) => {
   preprocessGDocs,
   preprocessHTML
 ];
-function createRuleOptions(blockContentType) {
-  const features = blockContentFeatures(blockContentType), enabledBlockStyles = features.styles.map(
-    (item) => item.value || item.title
-  ), enabledSpanDecorators = features.decorators.map(
-    (item) => item.value || item.title
-  ), enabledBlockAnnotations = features.annotations.map(
-    (item) => item.value || item.title || ""
-  ), enabledListTypes = features.lists.map(
-    (item) => item.value || item.title || ""
-  );
-  return {
-    enabledBlockStyles,
-    enabledSpanDecorators,
-    enabledBlockAnnotations,
-    enabledListTypes
-  };
-}
 function tagName(el) {
   if (el && "tagName" in el)
     return el.tagName.toLowerCase();
@@ -383,12 +296,12 @@ function defaultParseHtml() {
     );
   return (html) => new DOMParser().parseFromString(html, "text/html");
 }
-function flattenNestedBlocks(blocks2) {
+function flattenNestedBlocks(schema, blocks2) {
   let depth = 0;
   const flattened = [], traverse = (nodes) => {
     const toRemove = [];
     nodes.forEach((node) => {
-      depth === 0 && flattened.push(node), isPortableTextTextBlock(node) && (depth > 0 && (toRemove.push(node), flattened.push(node)), depth++, traverse(node.children)), node._type === "__block" && (toRemove.push(node), flattened.push(node.block));
+      depth === 0 && flattened.push(node), isTextBlock(schema, node) && (depth > 0 && (toRemove.push(node), flattened.push(node)), depth++, traverse(node.children)), node._type === "__block" && (toRemove.push(node), flattened.push(node.block));
     }), toRemove.forEach((node) => {
       nodes.splice(nodes.indexOf(node), 1);
     }), depth--;
@@ -406,9 +319,9 @@ function prevSpan(block, index) {
 function isWhiteSpaceChar(text) {
   return ["\xA0", " "].includes(text);
 }
-function trimWhitespace(blocks2) {
+function trimWhitespace(schema, blocks2) {
   return blocks2.forEach((block) => {
-    isPortableTextTextBlock(block) && block.children.forEach((child, index) => {
+    isTextBlock(schema, block) && block.children.forEach((child, index) => {
       if (!isMinimalSpan(child))
         return;
       const nextChild = nextSpan(block, index), prevChild = prevSpan(block, index);
@@ -416,14 +329,14 @@ function trimWhitespace(blocks2) {
     });
   }), blocks2;
 }
-function ensureRootIsBlocks(blocks2) {
+function ensureRootIsBlocks(schema, blocks2) {
   return blocks2.reduce((memo, node, i, original) => {
     if (node._type === "block")
       return memo.push(node), memo;
     if (node._type === "__block")
       return memo.push(node.block), memo;
     const lastBlock = memo[memo.length - 1];
-    if (i > 0 && !isPortableTextTextBlock(original[i - 1]) && isPortableTextTextBlock(lastBlock))
+    if (i > 0 && !isTextBlock(schema, original[i - 1]) && isTextBlock(schema, lastBlock))
       return lastBlock.children.push(node), memo;
     const block = {
       ...DEFAULT_BLOCK,
@@ -531,11 +444,11 @@ const blocks = {
   ...HTML_BLOCK_TAGS,
   ...HTML_HEADER_TAGS
 };
-function getBlockStyle(el, enabledBlockStyles) {
+function getBlockStyle(schema, el) {
   const childTag = tagName(el.firstChild), block = childTag && blocks[childTag];
-  return block && enabledBlockStyles.includes(block.style) ? block.style : BLOCK_DEFAULT_STYLE;
+  return block && schema.styles.some((style) => style.name === block.style) ? block.style : BLOCK_DEFAULT_STYLE;
 }
-function createGDocsRules(_blockContentType, options) {
+function createGDocsRules(schema) {
   return [
     {
       deserialize(el) {
@@ -556,7 +469,7 @@ function createGDocsRules(_blockContentType, options) {
             ...DEFAULT_BLOCK,
             listItem: getListItemStyle$1(el),
             level: getListItemLevel$1(el),
-            style: getBlockStyle(el, options.enabledBlockStyles),
+            style: getBlockStyle(schema, el),
             children: next(el.firstChild?.childNodes || [])
           };
       }
@@ -607,13 +520,13 @@ const whitespaceTextNodeRule = {
 function isWhitespaceTextNode(node) {
   return (node.nodeType === 3 && (node.textContent || "").replace(/[\r\n]/g, " ").replace(/\s\s+/g, " ") === " " && node.nextSibling && node.nextSibling.nodeType !== 3 && node.previousSibling && node.previousSibling.nodeType !== 3 || node.textContent !== " ") && tagName(node.parentNode) !== "body";
 }
-function resolveListItem(listNodeTagName, enabledListTypes) {
-  if (listNodeTagName === "ul" && enabledListTypes.includes("bullet"))
+function resolveListItem(schema, listNodeTagName) {
+  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";
 }
-function createHTMLRules(_blockContentType, options) {
+function createHTMLRules(schema, options) {
   return [
     whitespaceTextNodeRule,
     {
@@ -621,7 +534,9 @@ function createHTMLRules(_blockContentType, options) {
       deserialize(el) {
         if (tagName(el) !== "pre")
           return;
-        const isCodeEnabled = options.enabledBlockStyles.includes("code");
+        const isCodeEnabled = schema.styles.some(
+          (style) => style.name === "code"
+        );
         return {
           _type: "block",
           style: "normal",
@@ -674,11 +589,15 @@ function createHTMLRules(_blockContentType, options) {
           ...HTML_HEADER_TAGS
         }, tag = tagName(el);
         let block = tag ? blocks2[tag] : void 0;
-        if (block)
-          return el.parentNode && tagName(el.parentNode) === "li" ? next(el.childNodes) : (options.enabledBlockStyles.includes(block.style) || (block = DEFAULT_BLOCK), {
-            ...block,
-            children: next(el.childNodes)
-          });
+        if (!block)
+          return;
+        if (el.parentNode && tagName(el.parentNode) === "li")
+          return next(el.childNodes);
+        const blockStyle = block.style;
+        return schema.styles.some((style) => style.name === blockStyle) || (block = DEFAULT_BLOCK), {
+          ...block,
+          children: next(el.childNodes)
+        };
       }
     },
     // Ignore span tags
@@ -721,10 +640,7 @@ function createHTMLRules(_blockContentType, options) {
         const tag = tagName(el), listItem = tag ? HTML_LIST_ITEM_TAGS[tag] : void 0, parentTag = tagName(el.parentNode) || "";
         if (!listItem || !el.parentNode || !HTML_LIST_CONTAINER_TAGS[parentTag])
           return;
-        const enabledListItem = resolveListItem(
-          parentTag,
-          options.enabledListTypes
-        );
+        const enabledListItem = resolveListItem(schema, parentTag);
         return enabledListItem ? (listItem.listItem = enabledListItem, {
           ...listItem,
           children: next(el.childNodes)
@@ -735,7 +651,9 @@ function createHTMLRules(_blockContentType, options) {
     {
       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 {
             _type: "__decorator",
             name: decorator,
@@ -749,19 +667,18 @@ function createHTMLRules(_blockContentType, options) {
       deserialize(el, next) {
         if (tagName(el) !== "a")
           return;
-        const linkEnabled = options.enabledBlockAnnotations.includes("link"), href = isElement(el) && el.getAttribute("href");
-        if (!href)
-          return next(el.childNodes);
-        let markDef;
-        return linkEnabled ? (markDef = {
-          _key: options.keyGenerator ? options.keyGenerator() : keyGenerator(),
-          _type: "link",
-          href
-        }, {
+        const linkEnabled = schema.annotations.some(
+          (annotation) => annotation.name === "link"
+        ), href = isElement(el) && el.getAttribute("href");
+        return href ? linkEnabled ? {
           _type: "__annotation",
-          markDef,
+          markDef: {
+            _key: options.keyGenerator ? options.keyGenerator() : keyGenerator(),
+            _type: "link",
+            href
+          },
           children: next(el.childNodes)
-        }) : el.appendChild(el.ownerDocument.createTextNode(` (${href})`)) && next(el.childNodes);
+        } : el.appendChild(el.ownerDocument.createTextNode(` (${href})`)) && next(el.childNodes) : next(el.childNodes);
       }
     }
   ];
@@ -781,7 +698,7 @@ function isUnderline(el) {
 function isNotion(el) {
   return isElement(el) && !!el.getAttribute("data-is-notion");
 }
-function createNotionRules(_blockContentType) {
+function createNotionRules() {
   return [
     {
       deserialize(el) {
@@ -831,16 +748,16 @@ function createWordRules() {
     }
   ];
 }
-function createRules(blockContentType, options) {
+function createRules(schema, options) {
   return [
     ...createWordRules(),
     ...createNotionRules(),
-    ...createGDocsRules(blockContentType, options),
-    ...createHTMLRules(blockContentType, options)
+    ...createGDocsRules(schema),
+    ...createHTMLRules(schema, options)
   ];
 }
 class HtmlDeserializer {
-  blockContentType;
+  schema;
   rules;
   parseHtml;
   _markDefs = [];
@@ -850,17 +767,13 @@ class HtmlDeserializer {
    * @param blockContentType - Schema type for array containing _at least_ a block child type
    * @param options - Options for the deserialization process
    */
-  constructor(blockContentType, options = {}) {
-    const { rules = [], unstable_whitespaceOnPasteMode = "preserve" } = options;
-    if (!blockContentType)
-      throw new Error("Parameter 'blockContentType' is required");
-    const standardRules = createRules(blockContentType, {
-      ...createRuleOptions(blockContentType),
+  constructor(schema, options = {}) {
+    const { rules = [], unstable_whitespaceOnPasteMode = "preserve" } = options, standardRules = createRules(schema, {
       keyGenerator: options.keyGenerator
     });
-    this.rules = [...rules, ...standardRules];
+    this.schema = schema, this.rules = [...rules, ...standardRules];
     const parseHtml = options.parseHtml || defaultParseHtml();
-    this.blockContentType = blockContentType, this.parseHtml = (html) => preprocess(html, parseHtml, { unstable_whitespaceOnPasteMode }).body;
+    this.parseHtml = (html) => preprocess(html, parseHtml, { unstable_whitespaceOnPasteMode }).body;
   }
   /**
    * Deserialize HTML.
@@ -871,21 +784,19 @@ class HtmlDeserializer {
   deserialize = (html) => {
     this._markDefs = [];
     const { parseHtml } = this, fragment = parseHtml(html), children = Array.from(fragment.childNodes), blocks2 = trimWhitespace(
+      this.schema,
       flattenNestedBlocks(
-        ensureRootIsBlocks(this.deserializeElements(children))
+        this.schema,
+        ensureRootIsBlocks(this.schema, this.deserializeElements(children))
       )
     );
-    this._markDefs.length > 0 && blocks2.filter(
-      (block) => block._type === "block"
-    ).forEach((block) => {
+    return this._markDefs.length > 0 && blocks2.filter((block) => isTextBlock(this.schema, block)).forEach((block) => {
       block.markDefs = block.markDefs || [], block.markDefs = block.markDefs.concat(
         this._markDefs.filter((def) => flatten(
           block.children.map((child) => child.marks || [])
         ).includes(def._key))
       );
-    });
-    const type = this.blockContentType.of.find(findBlockType);
-    return type ? blocks2.map((block) => (block._type === "block" && (block._type = type.name), block)) : blocks2;
+    }), blocks2.map((block) => (block._type === "block" && (block._type = this.schema.block.name), block));
   };
   /**
    * Deserialize an array of DOM elements.
@@ -999,6 +910,11 @@ class HtmlDeserializer {
   };
 }
 function normalizeBlock(node, options = {}) {
+  const schema = {
+    span: {
+      name: "span"
+    }
+  };
   if (node._type !== (options.blockTypeName || "block"))
     return "_key" in node ? node : {
       ...node,
@@ -1023,13 +939,13 @@ function normalizeBlock(node, options = {}) {
   return block.children = block.children.reduce(
     (acc, child) => {
       const previousChild = acc[acc.length - 1];
-      return previousChild && isPortableTextSpan(child) && isPortableTextSpan(previousChild) && isEqual(previousChild.marks, child.marks) ? (lastChild && lastChild === child && child.text === "" && block.children.length > 1 || (previousChild.text += child.text), acc) : (acc.push(child), acc);
+      return previousChild && isSpan(schema, child) && isSpan(schema, previousChild) && isEqual(previousChild.marks, child.marks) ? (lastChild && lastChild === child && child.text === "" && block.children.length > 1 || (previousChild.text += child.text), acc) : (acc.push(child), acc);
     },
     []
   ).map((child) => {
     if (!child)
       throw new Error("missing child");
-    return child._key = options.keyGenerator ? options.keyGenerator() : keyGenerator(), isPortableTextSpan(child) && (child.marks ? allowedDecorators && (child.marks = child.marks.filter((mark) => {
+    return child._key = options.keyGenerator ? options.keyGenerator() : keyGenerator(), isSpan(schema, child) && (child.marks ? allowedDecorators && (child.marks = child.marks.filter((mark) => {
       const isAllowed = allowedDecorators.includes(mark), isUsed = block.markDefs?.some((def) => def._key === mark);
       return isAllowed || isUsed;
     })) : child.marks = [], usedMarkDefs.push(...child.marks)), child;
@@ -1037,14 +953,95 @@ function normalizeBlock(node, options = {}) {
     (markDef) => usedMarkDefs.includes(markDef._key)
   ), block;
 }
-function htmlToBlocks(html, blockContentType, options = {}) {
-  return new HtmlDeserializer(blockContentType, options).deserialize(html).map((block) => normalizeBlock(block, { keyGenerator: options.keyGenerator }));
+function findBlockType(type) {
+  return type.type ? findBlockType(type.type) : type.name === "block";
 }
-function getBlockContentFeatures(blockContentType) {
-  return blockContentFeatures(blockContentType);
+function getPortableTextSchema(blockContentType) {
+  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.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) {
+  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) {
+  return spanType.annotations.map((annotation) => ({
+    name: annotation.name,
+    title: annotation.title
+  }));
+}
+function resolveEnabledDecorators(spanType) {
+  return spanType.decorators.map((decorator) => ({
+    name: decorator.value,
+    title: decorator.title
+  }));
+}
+function resolveEnabledListItems(blockType) {
+  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) {
+  const list = options ? options.list : void 0;
+  return Array.isArray(list) ? list.map((item) => isTitledListValue(item) ? {
+    name: item.value ?? item.title,
+    title: item.title
+  } : {
+    name: item
+  }) : [];
+}
+function htmlToBlocks(html, blockContentType, options = {}) {
+  const schema = getPortableTextSchema(blockContentType);
+  return new HtmlDeserializer(schema, options).deserialize(html).map((block) => normalizeBlock(block, { keyGenerator: options.keyGenerator }));
 }
 export {
-  getBlockContentFeatures,
   htmlToBlocks,
   normalizeBlock,
   randomKey