@supernova-studio/client 0.31.0 → 0.32.0

package/dist/index.mjs

@@ -914,16 +914,18 @@ var PageBlockImageAlignment = z35.enum(["Left", "Center", "Stretch"]);
 var PageBlockTableCellAlignment = z35.enum(["Left", "Center", "Right"]);
 var PageBlockPreviewContainerSize = z35.enum(["Centered", "NaturalHeight"]);
 var PageBlockThemeDisplayMode = z35.enum(["Split", "Override"]);
+var PageBlockImageResourceReference = z35.object({
+  resourceId: z35.string(),
+  url: z35.string()
+});
+var PageBlockResourceFrameNodeReference = z35.object({
+  sourceId: z35.string(),
+  frameReferenceId: z35.string()
+});
 var PageBlockImageReference = z35.object({
   type: PageBlockImageType,
-  resource: z35.object({
-    url: z35.string(),
-    resourceId: z35.string()
-  }).optional(),
-  figmaFile: z35.object({
-    sourceId: z35.string(),
-    frameReferenceId: z35.string()
-  }).optional()
+  resource: PageBlockImageResourceReference.optional(),
+  figmaFile: PageBlockResourceFrameNodeReference.optional()
 });
 var PageBlockColorV2 = z35.object({
   value: z35.string(),
@@ -2594,13 +2596,13 @@ var PulsarContributionVariant = z118.object({
   thumbnailURL: nullishToOptional(z118.string())
 });
 var PulsarCustomBlock = z118.object({
-  title: z118.string(),
+  title: nullishToOptional(z118.string()),
   key: z118.string(),
-  category: z118.string(),
+  category: nullishToOptional(z118.string()),
   description: nullishToOptional(z118.string()),
-  iconURL: z118.string(),
-  mode: z118.enum(["array", "block"]),
-  properties: z118.array(PulsarBaseProperty)
+  iconURL: nullishToOptional(z118.string()),
+  mode: nullishToOptional(z118.enum(["array", "block"])),
+  properties: nullishToOptional(z118.array(PulsarBaseProperty)).transform((v) => v ?? [])
 });
 var ExporterType = z119.enum(["code", "documentation"]);
 var ExporterSource = z119.enum(["git", "upload"]);
@@ -3760,8 +3762,9 @@ var DTODuplicateDocumentationGroupInput = z135.object({
 var DTOCreateDocumentationTabInput = z135.object({
   // New group persistent id
   persistentId: z135.string().uuid(),
-  // Page that will become first tab of the tab group
-  fromPagePersistentId: z135.string(),
+  // If this is page, we will attempt to convert it to tab
+  // If this is tab group, we will add a new tab to it
+  tabContainerPersistentId: z135.string(),
   tabName: z135.string()
 });
 var DTODeleteDocumentationTabGroupInput = z135.object({
@@ -4613,6 +4616,9 @@ var newSchema = {
       attrs: {
         id: {
           default: null
+        },
+        variantId: {
+          default: null
         }
       },
       parseDOM: [
@@ -5011,35 +5017,166 @@ var BlockDefinitionUtils = {
 
 // src/yjs/docs-editor/blocks-to-prosemirror.ts
 import { prosemirrorJSONToYXmlFragment } from "y-prosemirror";
+
+// src/yjs/docs-editor/list-tree-builder.ts
+var ListTreeBuilder = class {
+  add(block, multiRichTextProperty) {
+    const list = this.createList(block, multiRichTextProperty);
+    if (!this.rootNode) {
+      this.rootNode = list;
+      return void 0;
+    }
+    if (block.data.indentLevel <= 0) {
+      if (this.rootNode.listType === list.listType) {
+        this.rootNode.children.push(...list.leadingChildren);
+        return;
+      } else {
+        const flushed = this.flush();
+        this.rootNode = list;
+        return flushed;
+      }
+    }
+    const listParent = this.getParentOfDepth(block.data.indentLevel);
+    const lastChild = listParent.children[listParent.children.length - 1];
+    if (lastChild?.type === "List") {
+      lastChild.children.push(...list.leadingChildren);
+      return;
+    } else {
+      listParent.children.push(list);
+    }
+  }
+  flush() {
+    const node = this.rootNode;
+    this.rootNode = void 0;
+    return node;
+  }
+  getParentOfDepth(depth) {
+    if (!this.rootNode || depth <= 0)
+      throw new Error("Invalid state");
+    let currentNode = this.rootNode;
+    let currentDepth = depth - 1;
+    while (currentDepth > 0) {
+      if (currentNode.children.length === 0)
+        return currentNode;
+      const lastChild = currentNode.children[currentNode.children.length - 1];
+      if (lastChild.type !== "List") {
+        return currentNode;
+      }
+      currentNode = lastChild;
+      currentDepth--;
+    }
+    return currentNode;
+  }
+  // next(block: PageBlockEditorModel, multiRichTextProperty: PageBlockDefinitionProperty): ListNode | undefined {
+  //   console.log("Next");
+  //   const list = this.createList(block, multiRichTextProperty);
+  //   if (this.currentList) {
+  //     if (this.currentList.listType === list.listType) {
+  //       // Merge items into the current list
+  //       this.currentList.children.push(...list.leadingChildren);
+  //       return undefined;
+  //     } else {
+  //       // Close the current list and start a new one
+  //       if (!this.currentParentList) {
+  //         const flushed = this.flush();
+  //         this.currentList = list;
+  //         return flushed;
+  //       } else {
+  //         this.currentList = list;
+  //         this.currentParentList.children.push(list);
+  //         this.parentMap.set(list, this.currentParentList);
+  //         return undefined;
+  //       }
+  //     }
+  //   } else {
+  //     this.currentList = list;
+  //     return undefined;
+  //   }
+  // }
+  // stepIn(block: PageBlockEditorModel, multiRichTextProperty: PageBlockDefinitionProperty): void {
+  //   console.log("Step in");
+  //   if (!this.currentList) {
+  //     throw new Error("Cannot step in without a list");
+  //   }
+  //   const list = this.createList(block, multiRichTextProperty);
+  //   this.currentParentList = this.currentList;
+  //   this.currentList = list;
+  //   this.currentParentList.children.push(list);
+  //   this.parentMap.set(list, this.currentParentList);
+  // }
+  // stepOut(block: PageBlockEditorModel, multiRichTextProperty: PageBlockDefinitionProperty): ListNode | undefined {
+  //   console.log("Step out");
+  //   if (!this.currentList) {
+  //     throw new Error("Cannot step out without a list");
+  //   }
+  //   if (!this.currentParentList) {
+  //     throw new Error("Cannot step out without a parent list");
+  //   }
+  //   const newCurrentList = this.currentParentList;
+  //   const newParent = this.parentMap.get(newCurrentList);
+  //   this.currentList = newCurrentList;
+  //   this.currentParentList = newParent;
+  //   return this.next(block, multiRichTextProperty);
+  // }
+  // flush(): ListNode | undefined {
+  //   const result = this.currentList;
+  //   this.currentList = undefined;
+  //   this.currentParentList = undefined;
+  //   this.parentMap.clear();
+  //   return result;
+  // }
+  createList(block, multiRichTextProperty) {
+    const blockItem = BlockParsingUtils.singleBlockItem(block);
+    const multiRichTextValue = BlockParsingUtils.multiRichTextPropertyValue(blockItem, multiRichTextProperty.id);
+    const parsedOptions = PageBlockDefinitionMutiRichTextOptions.optional().parse(multiRichTextProperty.options);
+    const style = parsedOptions?.multiRichTextStyle ?? "Default";
+    const leadingChildren = multiRichTextValue.value.map((t) => {
+      return {
+        type: "ListItem",
+        text: t
+      };
+    });
+    if (!leadingChildren.length) {
+      leadingChildren.push({ type: "ListItem", text: { spans: [] } });
+    }
+    return {
+      type: "List",
+      listType: style === "OL" ? "Ordered" : "Unordered",
+      leadingChildren,
+      block,
+      children: []
+    };
+  }
+};
+
+// src/yjs/docs-editor/blocks-to-prosemirror.ts
 function pageToYXmlFragment(page, definitions, fragment) {
   const doc = pageToProsemirrorDoc(page, definitions);
   return prosemirrorJSONToYXmlFragment(pmSchema, doc, fragment);
 }
 function pageToProsemirrorDoc(page, definitions) {
   const definitionsMap = mapByUnique(definitions, (d) => d.id);
+  const children = [];
+  let blockBuffer = [];
+  page.blocks.forEach((b) => {
+    if (b.type === "Block") {
+      blockBuffer.push(b);
+    } else if (b.type === "Section") {
+      if (blockBuffer.length) {
+        children.push(...blocksToProsemirrorNodes(blockBuffer, definitionsMap));
+        blockBuffer = [];
+      }
+      children.push(internalSectionToProsemirrorNode(b, definitionsMap));
+    }
+  });
+  if (blockBuffer.length) {
+    children.push(...blocksToProsemirrorNodes(blockBuffer, definitionsMap));
+  }
   return {
     type: "doc",
-    content: page.blocks.map((b) => {
-      switch (b.type) {
-        case "Block":
-          return blockToProsemirrorNode(b, blockDefinitionForBlock(b, definitions));
-        case "Section":
-          return internalSectionToProsemirrorNode(b, definitionsMap);
-      }
-    }).filter(nonNullFilter)
+    content: children
   };
 }
-function blockDefinitionForBlock(block, definitions) {
-  const definition = definitions.find((d) => d.id === block.data.packageId);
-  if (!definition) {
-    throw new Error(`Could not find definition for ${block.id} (${block.data.packageId})`);
-  }
-  return definition;
-}
-function sectionToProsemirrorNode(section, definitions) {
-  const definitionsMap = mapByUnique(definitions, (d) => d.id);
-  return internalSectionToProsemirrorNode(section, definitionsMap);
-}
 function internalSectionToProsemirrorNode(section, definitionsMap) {
   return {
     type: "tabsSection",
@@ -5061,9 +5198,7 @@ function sectionItemToProsemirrorNode(sectionItem, definitionsMap) {
   };
 }
 function sectionColumnToProsemirrorNode(sectionColumn, definitionsMap) {
-  const blocks2 = sectionColumn.blocks.map((block) => {
-    return internalBlockToProsemirrorNode(block, definitionsMap);
-  }).filter(nonNullFilter);
+  const blocks2 = blocksToProsemirrorNodes(sectionColumn.blocks, definitionsMap);
   if (!blocks2.length) {
     blocks2.push({
       type: "paragraph",
@@ -5081,12 +5216,35 @@ function sectionColumnToProsemirrorNode(sectionColumn, definitionsMap) {
     content: blocks2
   };
 }
-function internalBlockToProsemirrorNode(block, definitionsMap) {
-  const definition = definitionsMap.get(block.data.packageId);
-  if (!definition) {
-    throw SupernovaException.shouldNotHappen(`Could not find definition for ${block.id} (${block.data.packageId})`);
+function blocksToProsemirrorNodes(blocks2, definitionsMap) {
+  const result = [];
+  const listTreeBuilder = new ListTreeBuilder();
+  blocks2.forEach((b) => {
+    const definition = definitionsMap.get(b.data.packageId);
+    if (!definition) {
+      console.warn(`Could not find definition for ${b.id} (${b.data.packageId})`);
+      return;
+    }
+    const multiRichTextProp = BlockDefinitionUtils.firstMultiRichTextProperty(definition);
+    if (multiRichTextProp) {
+      const node = listTreeBuilder.add(b, multiRichTextProp);
+      if (node) {
+        result.push(serializeAsMultiRichTextBlock(node));
+      }
+    } else {
+      const tree2 = listTreeBuilder.flush();
+      if (tree2) {
+        result.push(serializeAsMultiRichTextBlock(tree2));
+      }
+      const node = blockToProsemirrorNode(b, definition);
+      node && result.push(node);
+    }
+  });
+  const tree = listTreeBuilder.flush();
+  if (tree) {
+    result.push(serializeAsMultiRichTextBlock(tree));
   }
-  return blockToProsemirrorNode(block, definition);
+  return result;
 }
 function blockToProsemirrorNode(block, definition) {
   const richTextProperty = BlockDefinitionUtils.firstRichTextProperty(definition);
@@ -5097,14 +5255,6 @@ function blockToProsemirrorNode(block, definition) {
       property: richTextProperty
     });
   }
-  const multiRichTextProperty = BlockDefinitionUtils.firstMultiRichTextProperty(definition);
-  if (multiRichTextProperty) {
-    return serializeAsMultiRichTextBlock({
-      block,
-      definition,
-      property: multiRichTextProperty
-    });
-  }
   const tableProperty = BlockDefinitionUtils.firstTableProperty(definition);
   if (tableProperty) {
     return serializeAsTable({
@@ -5146,7 +5296,7 @@ function serializeAsRichTextBlock(input) {
 function serializeAsParagraph(input) {
   return {
     type: "paragraph",
-    attrs: serializeBlockNodeAttributes(input),
+    attrs: serializeBlockNodeAttributes(input.block),
     ...serializeRichTextNodePart(input.richTextPropertyValue.value)
   };
 }
@@ -5154,7 +5304,7 @@ function serializeAsHeading(input) {
   return {
     type: "heading",
     attrs: {
-      ...serializeBlockNodeAttributes(input),
+      ...serializeBlockNodeAttributes(input.block),
       level: richTextHeadingLevel(input.property)
     },
     ...serializeRichTextNodePart(input.richTextPropertyValue.value)
@@ -5163,7 +5313,7 @@ function serializeAsHeading(input) {
 function serializeAsBlockquote(input) {
   return {
     type: "blockquote",
-    attrs: serializeBlockNodeAttributes(input),
+    attrs: serializeBlockNodeAttributes(input.block),
     ...serializeRichTextNodePart(input.richTextPropertyValue.value)
   };
 }
@@ -5172,62 +5322,70 @@ function serializeAsCallout(input) {
   return {
     type: "callout",
     attrs: {
-      ...serializeBlockNodeAttributes(input),
+      ...serializeBlockNodeAttributes(input.block),
       type: serializeCalloutType(calloutType)
     },
     ...serializeRichTextNodePart(input.richTextPropertyValue.value)
   };
 }
-function serializeAsMultiRichTextBlock(input) {
-  const { block, definition, property: multiRichTextProperty } = input;
-  const blockItem = BlockParsingUtils.singleBlockItem(block);
-  const textPropertyValue = BlockParsingUtils.multiRichTextPropertyValue(blockItem, multiRichTextProperty.id);
-  const enrichedInput = { ...input, multiRichTextPropertyValue: textPropertyValue };
-  const parsedOptions = PageBlockDefinitionMutiRichTextOptions.optional().parse(multiRichTextProperty.options);
-  const style = parsedOptions?.multiRichTextStyle ?? "Default";
-  switch (style) {
-    case "Default":
-      return serializeAsMultiParagraph(enrichedInput);
-    case "OL":
-      return serializeAsOrderedList(enrichedInput);
-    case "UL":
-      return serializeAsUnorderedList(enrichedInput);
+function serializeAsMultiRichTextBlock(node) {
+  switch (node.listType) {
+    case "Ordered":
+      return serializeAsOrderedList(node);
+    case "Unordered":
+      return serializeAsUnorderedList(node);
   }
 }
-function serializeAsMultiParagraph(input) {
-  return {
-    type: "bulletList",
-    attrs: {
-      ...serializeBlockNodeAttributes(input)
-    },
-    content: input.multiRichTextPropertyValue.value.map(serializeAsListItem)
-  };
-}
-function serializeAsOrderedList(input) {
+function serializeAsOrderedList(tree) {
   return {
     type: "orderedList",
     attrs: {
-      ...serializeBlockNodeAttributes(input),
+      ...serializeBlockNodeAttributes(tree.block),
       start: "1"
     },
-    content: input.multiRichTextPropertyValue.value.map(serializeAsListItem)
+    content: serializeListContent(tree)
   };
 }
-function serializeAsUnorderedList(input) {
+function serializeAsUnorderedList(tree) {
   return {
     type: "bulletList",
     attrs: {
-      ...serializeBlockNodeAttributes(input)
+      ...serializeBlockNodeAttributes(tree.block)
     },
-    content: input.multiRichTextPropertyValue.value.map(serializeAsListItem)
+    content: serializeListContent(tree)
   };
 }
-function serializeAsListItem(text) {
+function serializeListContent(tree) {
+  const result = tree.leadingChildren.map((i) => serializeAsTextListItem(i.text));
+  for (const child of tree.children) {
+    if (child.type === "ListItem") {
+      result.push(serializeAsTextListItem(child.text));
+    } else if (child.type === "List") {
+      const previousNode = result[result.length - 1];
+      if (!previousNode) {
+        throw SupernovaException.shouldNotHappen("List node without previous node");
+      }
+      if (!previousNode.content) {
+        throw SupernovaException.shouldNotHappen("List item node has no content");
+      }
+      const serializedList = serializeAsMultiRichTextBlock(child);
+      previousNode.content.push(serializedList);
+    } else {
+      throw SupernovaException.shouldNotHappen(`Unknown list node type: ${child}`);
+    }
+  }
+  return result;
+}
+function serializeAsTextListItem(text) {
   return {
     type: "listItem",
     content: [
       {
         type: "paragraph",
+        attrs: {
+          definitionId: "io.supernova.block.rich-text",
+          variantId: "default"
+        },
         content: serializeRichText(text)
       }
     ]
@@ -5240,7 +5398,7 @@ function serializeAsTable(input) {
   return {
     type: "tableContainer",
     attrs: {
-      ...serializeBlockNodeAttributes(input),
+      ...serializeBlockNodeAttributes(input.block),
       hasBorder: table.showBorder ?? true
     },
     content: [
@@ -5329,11 +5487,10 @@ function serializeTableNode(node) {
 function serializeAsDivider(input) {
   return {
     type: "horizontalRule",
-    attrs: serializeBlockNodeAttributes(input)
+    attrs: serializeBlockNodeAttributes(input.block)
   };
 }
-function serializeBlockNodeAttributes(input) {
-  const { block } = input;
+function serializeBlockNodeAttributes(block) {
   return {
     id: block.id,
     definitionId: block.data.packageId,
@@ -5385,6 +5542,7 @@ function serializeRichText(richText) {
   return richText.spans.map(serializeTextSpan).flat();
 }
 function serializeTextSpan(span) {
+  const hardBreakType = "hardBreak";
   const marks = span.attributes.map(serializeTextSpanAttribute);
   const textParts = span.text.split("\n");
   const interspersed = [
@@ -5397,7 +5555,7 @@ function serializeTextSpan(span) {
   for (let i = 1; i < textParts.length; i++) {
     interspersed.push(
       {
-        type: "hardBreak"
+        type: hardBreakType
       },
       {
         type: "text",
@@ -5406,7 +5564,7 @@ function serializeTextSpan(span) {
       }
     );
   }
-  return interspersed.filter((t) => !!t.text);
+  return interspersed.filter((t) => t.type === hardBreakType || !!t.text);
 }
 function serializeTextSpanAttribute(spanAttribute) {
   switch (spanAttribute.type) {
@@ -5415,7 +5573,7 @@ function serializeTextSpanAttribute(spanAttribute) {
     case "Italic":
       return { type: "italic", attrs: {} };
     case "Strikethrough":
-      return { type: "strikethrough", attrs: {} };
+      return { type: "strike", attrs: {} };
     case "Code":
       return { type: "code", attrs: {} };
     case "Link":
@@ -5468,9 +5626,6 @@ function serializeCustomBlockNodeType(block, definition) {
       return "blockNode";
   }
 }
-function nonNullFilter(item) {
-  return !!item;
-}
 
 // src/yjs/docs-editor/mock.ts
 function getMockPageBlockDefinitions() {
@@ -7003,7 +7158,7 @@ function internalProsemirrorNodeToSection(prosemirrorNode, definitionsMap) {
       contentExpandToEdges: true,
       expandToEdges: true
     },
-    items: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItem").map((c) => prosemirrorNodeToSectionItem(c, definitionsMap)).filter(nonNullFilter2)
+    items: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItem").map((c) => prosemirrorNodeToSectionItem(c, definitionsMap)).filter(nonNullFilter)
   };
 }
 function prosemirrorNodeToSectionItem(prosemirrorNode, definitionsMap) {
@@ -7013,7 +7168,7 @@ function prosemirrorNodeToSectionItem(prosemirrorNode, definitionsMap) {
   return {
     id,
     title: getProsemirrorAttribute(prosemirrorNode, "title", z152.string()) ?? "",
-    columns: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItemColumn").map((c) => prosemirrorNodeToSectionColumns(c, definitionsMap)).filter(nonNullFilter2)
+    columns: (prosemirrorNode.content ?? []).filter((c) => c.type === "sectionItemColumn").map((c) => prosemirrorNodeToSectionColumns(c, definitionsMap)).filter(nonNullFilter)
   };
 }
 function prosemirrorNodeToSectionColumns(prosemirrorNode, definitionsMap) {
@@ -7036,12 +7191,12 @@ function internalProsemirrorNodesToPageItems(prosemirrorNodes, definitionsMap) {
     } else {
       return internalProsemirrorNodeToBlock(prosemirrorNode, definitionsMap);
     }
-  }).filter(nonNullFilter2);
+  }).filter(nonNullFilter);
 }
 function internalProsemirrorNodesToBlocks(prosemirrorNodes, definitionsMap) {
   return prosemirrorNodes.map((prosemirrorNode) => {
     return internalProsemirrorNodeToBlock(prosemirrorNode, definitionsMap);
-  }).filter(nonNullFilter2);
+  }).filter(nonNullFilter);
 }
 function internalProsemirrorNodeToBlock(prosemirrorNode, definitionsMap) {
   let definitionId = getProsemirrorAttribute(prosemirrorNode, "definitionId", z152.string());
@@ -7154,7 +7309,7 @@ function parseAsMultiRichText(prosemirrorNode, definition, property) {
                 if (paragraph.type !== "paragraph")
                   return parseRichText([]);
                 return parseRichText(paragraph.content ?? []);
-              }).filter(nonNullFilter2)
+              }).filter(nonNullFilter)
             }
           }
         }
@@ -7164,7 +7319,7 @@ function parseAsMultiRichText(prosemirrorNode, definition, property) {
 }
 function parseRichText(spans) {
   return {
-    spans: spans.map(parseRichTextSpan).filter(nonNullFilter2)
+    spans: spans.map(parseRichTextSpan).filter(nonNullFilter)
   };
 }
 function parseRichTextSpan(span) {
@@ -7173,7 +7328,7 @@ function parseRichTextSpan(span) {
   const marks = span.marks ?? [];
   return {
     text: span.text,
-    attributes: marks.map(parseRichTextAttribute).filter(nonNullFilter2)
+    attributes: marks.map(parseRichTextAttribute).filter(nonNullFilter)
   };
 }
 function parseRichTextAttribute(mark) {
@@ -7182,7 +7337,7 @@ function parseRichTextAttribute(mark) {
       return { type: "Bold" };
     case "italic":
       return { type: "Italic" };
-    case "strikethrough":
+    case "strike":
       return { type: "Strikethrough" };
     case "code":
       return { type: "Code" };
@@ -7237,7 +7392,7 @@ function parseAsTable(prosemirrorNode, definition, property) {
   };
   tableValue.value = rows.map((row) => {
     return {
-      cells: (row.content ?? []).map(parseAsTableCell).filter(nonNullFilter2)
+      cells: (row.content ?? []).map(parseAsTableCell).filter(nonNullFilter)
     };
   });
   return {
@@ -7269,7 +7424,7 @@ function parseAsTableCell(prosemirrorNode) {
   if (columnWidthArray) {
     columnWidth = columnWidthArray[0];
   }
-  const tableNodes = (prosemirrorNode.content ?? []).map(parseAsTableNode).filter(nonNullFilter2);
+  const tableNodes = (prosemirrorNode.content ?? []).map(parseAsTableNode).filter(nonNullFilter);
   return {
     id,
     alignment: parseTableCellAlignment(textAlign),
@@ -7416,7 +7571,7 @@ function parseBlockItems(prosemirrorNode, definition) {
     console.error("Block `items` property must be a json array");
     return null;
   }
-  return itemsJson.map((i) => parseItem(i, definition)).filter(nonNullFilter2);
+  return itemsJson.map((i) => parseItem(i, definition)).filter(nonNullFilter);
 }
 function parseAppearance(prosemirrorNode) {
   let appearance = {};
@@ -7540,7 +7695,7 @@ function getProsemirrorAttribute(prosemirrorNode, attributeName, validationSchem
     return void 0;
   }
 }
-function nonNullFilter2(item) {
+function nonNullFilter(item) {
   return item !== null;
 }
 function mapByUnique2(items, keyFn) {
@@ -7622,8 +7777,6 @@ export {
   PageBlockEditorModel,
   PageSectionEditorModel,
   WorkspaceConfigurationPayload,
-  blockDefinitionForBlock,
-  blockToProsemirrorNode,
   buildDocPagePublishPaths,
   calculateElementParentChain,
   documentationElementsToHierarchyDto,
@@ -7642,7 +7795,6 @@ export {
   prosemirrorNodeToBlock,
   prosemirrorNodeToSection,
   prosemirrorNodesToBlocks,
-  sectionToProsemirrorNode,
   serializeAsCustomBlock,
   validateSsoPayload,
   yDocToPage,