@blocknote/xl-pdf-exporter 0.19.0

package/src/pdf/pdfExporter.tsx

@@ -0,0 +1,297 @@
+import {
+  Block,
+  BlockNoteSchema,
+  BlockSchema,
+  COLORS_DEFAULT,
+  DefaultProps,
+  Exporter,
+  ExporterOptions,
+  InlineContentSchema,
+  StyleSchema,
+  StyledText,
+} from "@blocknote/core";
+import {
+  Document,
+  Font,
+  Link,
+  Page,
+  StyleSheet,
+  Text,
+  TextProps,
+  View,
+} from "@react-pdf/renderer";
+import { corsProxyResolveFileUrl } from "@shared/api/corsProxy.js";
+import { loadFontDataUrl } from "../../../../shared/util/fileUtil.js";
+
+import { Style } from "./types.js";
+
+const FONT_SIZE = 16;
+const PIXELS_PER_POINT = 0.75;
+
+type Options = ExporterOptions & {
+  /**
+   *
+   * @default uses the remote emoji source hosted on cloudflare (https://cdnjs.cloudflare.com/ajax/libs/twemoji/14.0.2/72x72/)
+   */
+  emojiSource: false | ReturnType<typeof Font.getEmojiSource>;
+};
+
+/**
+ * Exports a BlockNote document to a .pdf file using the react-pdf library.
+ */
+export class PDFExporter<
+  B extends BlockSchema,
+  S extends StyleSchema,
+  I extends InlineContentSchema
+> extends Exporter<
+  B,
+  I,
+  S,
+  React.ReactElement<Text>,
+  React.ReactElement<Link> | React.ReactElement<Text>,
+  TextProps["style"],
+  React.ReactElement<Text>
+> {
+  private fontsRegistered = false;
+
+  public styles = StyleSheet.create({
+    page: {
+      paddingTop: 35,
+      paddingBottom: 65,
+      paddingHorizontal: 35,
+      fontFamily: "Inter",
+      fontSize: FONT_SIZE * PIXELS_PER_POINT, //  pixels
+      lineHeight: 1.5,
+    },
+    section: {},
+    block: {},
+    blockChildren: {},
+    header: {},
+    footer: {
+      // @ts-ignore
+      position: "absolute",
+    },
+  });
+
+  public readonly options: Options;
+
+  public constructor(
+    /**
+     * The schema of your editor. The mappings are automatically typed checked against this schema.
+     */
+    protected readonly schema: BlockNoteSchema<B, I, S>,
+    /**
+     * The mappings that map the BlockNote schema to the react-pdf content.
+     *
+     * Pass {@link pdfDefaultSchemaMappings} for the default schema.
+     */
+    mappings: Exporter<
+      NoInfer<B>,
+      NoInfer<I>,
+      NoInfer<S>,
+      React.ReactElement<Text>, // RB
+      React.ReactElement<Link> | React.ReactElement<Text>, // RI
+      TextProps["style"], // RS
+      React.ReactElement<Text> // TS
+    >["mappings"],
+    options?: Partial<Options>
+  ) {
+    const defaults = {
+      emojiSource: {
+        format: "png",
+        url: "https://cdnjs.cloudflare.com/ajax/libs/twemoji/14.0.2/72x72/",
+      },
+      resolveFileUrl: corsProxyResolveFileUrl,
+      colors: COLORS_DEFAULT,
+    } satisfies Partial<Options>;
+
+    const newOptions = {
+      ...defaults,
+      ...options,
+    };
+    super(schema, mappings, newOptions);
+    this.options = newOptions;
+  }
+
+  /**
+   * Mostly for internal use, you probably want to use `toBlob` or `toReactPDFDocument` instead.
+   */
+  public transformStyledText(styledText: StyledText<S>) {
+    const stylesArray = this.mapStyles(styledText.styles);
+    const styles = Object.assign({}, ...stylesArray);
+    return <Text style={styles}>{styledText.text}</Text>;
+  }
+
+  /**
+   * Mostly for internal use, you probably want to use `toBlob` or `toReactPDFDocument` instead.
+   */
+  public async transformBlocks(
+    blocks: Block<B, I, S>[], // Or BlockFromConfig<B[keyof B], I, S>?
+    nestingLevel = 0
+  ): Promise<React.ReactElement<Text>[]> {
+    const ret: React.ReactElement<Text>[] = [];
+    let numberedListIndex = 0;
+
+    for (const b of blocks) {
+      if (b.type === "numberedListItem") {
+        numberedListIndex++;
+      } else {
+        numberedListIndex = 0;
+      }
+      const children = await this.transformBlocks(b.children, nestingLevel + 1);
+      const self = await this.mapBlock(
+        b as any,
+        nestingLevel,
+        numberedListIndex
+      ); // TODO: any
+
+      const style = this.blocknoteDefaultPropsToReactPDFStyle(b.props as any);
+      ret.push(
+        <>
+          <View
+            style={{
+              paddingVertical: 3 * PIXELS_PER_POINT,
+              ...this.styles.block,
+              ...style,
+            }}>
+            {self}
+          </View>
+          {children.length > 0 && (
+            <View
+              style={{
+                marginLeft: FONT_SIZE * 1.5 * PIXELS_PER_POINT,
+                ...this.styles.blockChildren,
+              }}>
+              {children}
+            </View>
+          )}
+        </>
+      );
+    }
+
+    return ret;
+  }
+
+  protected async registerFonts() {
+    if (this.fontsRegistered) {
+      return;
+    }
+
+    if (this.options.emojiSource) {
+      Font.registerEmojiSource(this.options.emojiSource);
+    }
+    let font = await loadFontDataUrl(
+      await import("@shared/assets/fonts/inter/Inter_18pt-Regular.ttf")
+    );
+    Font.register({
+      family: "Inter",
+      src: font,
+    });
+
+    font = await loadFontDataUrl(
+      await import("@shared/assets/fonts/inter/Inter_18pt-Italic.ttf")
+    );
+    Font.register({
+      family: "Inter",
+      fontStyle: "italic",
+      src: font,
+    });
+
+    font = await loadFontDataUrl(
+      await import("@shared/assets/fonts/inter/Inter_18pt-Bold.ttf")
+    );
+    Font.register({
+      family: "Inter",
+      src: font,
+      fontWeight: "bold",
+    });
+
+    font = await loadFontDataUrl(
+      await import("@shared/assets/fonts/inter/Inter_18pt-BoldItalic.ttf")
+    );
+    Font.register({
+      family: "Inter",
+      fontStyle: "italic",
+      src: font,
+      fontWeight: "bold",
+    });
+
+    this.fontsRegistered = true;
+  }
+
+  /**
+   * Convert a document (array of Blocks) to a react-pdf Document.
+   */
+  public async toReactPDFDocument(
+    blocks: Block<B, I, S>[],
+    options: {
+      /**
+       * Add a header to every page.
+       * The React component passed must be a React-PDF component
+       */
+      header?: React.ReactElement;
+      /**
+       * Add a footer to every page.
+       * The React component passed must be a React-PDF component
+       */
+      footer?: React.ReactElement;
+    } = {}
+  ) {
+    await this.registerFonts();
+
+    return (
+      <Document>
+        <Page dpi={100} size="A4" style={this.styles.page}>
+          {options.header && (
+            <View fixed style={this.styles.header}>
+              {options.header}
+            </View>
+          )}
+          <View style={this.styles.section}>
+            {await this.transformBlocks(blocks)}
+          </View>
+          {options.footer && (
+            <View
+              fixed
+              style={[
+                {
+                  left: this.styles.page.paddingHorizontal || 0,
+                  bottom: (this.styles.page.paddingBottom || 0) / 2,
+                  right: this.styles.page.paddingHorizontal || 0,
+                },
+                this.styles.footer,
+              ]}>
+              {options.footer}
+            </View>
+          )}
+        </Page>
+      </Document>
+    );
+  }
+
+  protected blocknoteDefaultPropsToReactPDFStyle(
+    props: Partial<DefaultProps>
+  ): Style {
+    return {
+      textAlign: props.textAlignment,
+      backgroundColor:
+        props.backgroundColor === "default" || !props.backgroundColor
+          ? undefined
+          : this.options.colors[
+              props.backgroundColor as keyof typeof this.options.colors
+            ].background,
+      color:
+        props.textColor === "default" || !props.textColor
+          ? undefined
+          : this.options.colors[
+              props.textColor as keyof typeof this.options.colors
+            ].text,
+      alignItems:
+        props.textAlignment === "right"
+          ? "flex-end"
+          : props.textAlignment === "center"
+          ? "center"
+          : undefined,
+    };
+  }
+}

package/src/pdf/types.ts

@@ -0,0 +1,3 @@
+import { Styles } from "@react-pdf/renderer";
+
+export type Style = Styles[keyof Styles];

package/src/pdf/util/listItem.tsx

@@ -0,0 +1,70 @@
+import { Path, StyleSheet, Svg, Text, View } from "@react-pdf/renderer";
+import { Style } from "../types.js";
+
+// https://github.com/diegomura/react-pdf/issues/134
+
+const PIXELS_PER_POINT = 0.75;
+
+const styles = StyleSheet.create({
+  listItem: {
+    display: "flex",
+    flexDirection: "row",
+    gap: 8 * PIXELS_PER_POINT,
+    paddingRight: 10, // otherwise text overflows, seems like a react-pdf / yoga bug
+  },
+  bullet: {
+    fontFamily: "", // TODO: add symbol font
+  },
+});
+
+export const BULLET_MARKER = "\u2022";
+
+// https://fonts.google.com/icons?selected=Material+Symbols+Outlined:check_box_outline_blank:FILL@0;wght@400;GRAD@0;opsz@24&icon.size=24&icon.color=undefined
+export const CHECK_MARKER_UNCHECKED = (
+  <Svg
+    style={{ marginTop: 2 }}
+    height="12"
+    viewBox="0 -960 960 960"
+    width="12"
+    fill="undefined">
+    <Path d="M200-120q-33 0-56.5-23.5T120-200v-560q0-33 23.5-56.5T200-840h560q33 0 56.5 23.5T840-760v560q0 33-23.5 56.5T760-120H200Zm0-80h560v-560H200v560Z" />
+  </Svg>
+);
+
+// https://fonts.google.com/icons?selected=Material+Symbols+Outlined:check_box:FILL@0;wght@400;GRAD@0;opsz@24&icon.size=24&icon.color=undefined
+export const CHECK_MARKER_CHECKED = (
+  <Svg
+    style={{ marginTop: 2 }}
+    height="12"
+    viewBox="0 -960 960 960"
+    width="12"
+    fill="undefined">
+    <Path d="m424-312 282-282-56-56-226 226-114-114-56 56 170 170ZM200-120q-33 0-56.5-23.5T120-200v-560q0-33 23.5-56.5T200-840h560q33 0 56.5 23.5T840-760v560q0 33-23.5 56.5T760-120H200Zm0-80h560v-560H200v560Zm0-560v560-560Z" />
+  </Svg>
+);
+
+export const ListItem = ({
+  listMarker,
+  children,
+  style,
+}: {
+  listMarker: string | React.ReactNode;
+  children: React.ReactNode;
+  style?: Style;
+}) => {
+  return (
+    <View style={[styles.listItem, style || {}]}>
+      <View style={styles.bullet}>
+        {/* <Svg width={2} height={2}>
+            <Circle cx="1" cy="1" r="2" fill="black" />
+          </Svg> */}
+        {typeof listMarker === "string" ? (
+          <Text>{listMarker}</Text>
+        ) : (
+          listMarker
+        )}
+      </View>
+      {children}
+    </View>
+  );
+};

package/src/pdf/util/table/Table.tsx

@@ -0,0 +1,76 @@
+import {
+  Exporter,
+  InlineContentSchema,
+  StyleSchema,
+  TableContent,
+} from "@blocknote/core";
+import { StyleSheet, View } from "@react-pdf/renderer";
+const PIXELS_PER_POINT = 0.75;
+
+// ( impossible?) to make tables with flex that don't have a fixed / 100% width?
+// we'd need to measure the width of every column manually
+const styles = StyleSheet.create({
+  tableContainer: {
+    // width: "100%",
+  },
+  row: {
+    flexDirection: "row",
+    flexWrap: "wrap",
+    // width: "100%",
+    // justifyContent: "space-between",
+    display: "flex",
+  },
+  cell: {
+    paddingHorizontal: 5 * PIXELS_PER_POINT,
+    paddingTop: 3 * PIXELS_PER_POINT,
+    // paddingBottom: 1 * PIXELS_PER_POINT, should be 3px but looks odd, better with no padding Bottom
+    borderLeft: "1px solid #ddd",
+    borderTop: "1px solid #ddd",
+    wordWrap: "break-word",
+    whiteSpace: "pre-wrap",
+  },
+  bottomCell: {
+    borderBottom: "1px solid #ddd",
+  },
+  rightCell: {
+    borderRight: "1px solid #ddd",
+  },
+});
+
+export const Table = (props: {
+  data: TableContent<InlineContentSchema>;
+  transformer: Exporter<
+    any,
+    InlineContentSchema,
+    StyleSchema,
+    any,
+    any,
+    any,
+    any
+  >;
+}) => (
+  <View style={styles.tableContainer} wrap={false}>
+    {props.data.rows.map((row, index) => (
+      <View
+        style={[
+          styles.row,
+          index === props.data.rows.length - 1 ? styles.bottomCell : {},
+        ]}
+        key={index}>
+        {row.cells.map((cell, index) => (
+          <View
+            style={[
+              styles.cell,
+              index === row.cells.length - 1 ? styles.rightCell : {},
+              props.data.columnWidths[index]
+                ? { width: props.data.columnWidths[index] }
+                : { flex: 1 },
+            ]}
+            key={index}>
+            {props.transformer.transformInlineContent(cell)}
+          </View>
+        ))}
+      </View>
+    ))}
+  </View>
+);

package/src/vite-env.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="vite/client" />
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface ImportMetaEnv {
+  //   readonly VITE_APP_TITLE: string;
+  // more env variables...
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

package/types/src/Exporter.d.ts

@@ -0,0 +1,26 @@
+import { BlockFromConfig, BlockNoteSchema, BlockSchema, COLORS_DEFAULT, InlineContent, InlineContentSchema, StyleSchema, StyledText, Styles } from "@blocknote/core";
+import { BlockMapping, InlineContentMapping, StyleMapping } from "./mapping.js";
+export type ExporterOptions = {
+    resolveFileUrl?: (url: string) => Promise<string | Blob>;
+    colors: typeof COLORS_DEFAULT;
+};
+export declare abstract class Exporter<B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema, RB, RI, RS, TS> {
+    readonly mappings: {
+        blockMapping: BlockMapping<B, I, S, RB, RI>;
+        inlineContentMapping: InlineContentMapping<I, S, RI, TS>;
+        styleMapping: StyleMapping<S, RS>;
+    };
+    readonly options: ExporterOptions;
+    constructor(_schema: BlockNoteSchema<B, I, S>, // only used for type inference
+    mappings: {
+        blockMapping: BlockMapping<B, I, S, RB, RI>;
+        inlineContentMapping: InlineContentMapping<I, S, RI, TS>;
+        styleMapping: StyleMapping<S, RS>;
+    }, options: ExporterOptions);
+    resolveFile(url: string): Promise<Blob>;
+    mapStyles(styles: Styles<S>): RS[];
+    mapInlineContent(inlineContent: InlineContent<I, S>): RI;
+    transformInlineContent(inlineContentArray: InlineContent<I, S>[]): RI[];
+    abstract transformStyledText(styledText: StyledText<S>): TS;
+    mapBlock(block: BlockFromConfig<B[keyof B], I, S>, nestingLevel: number, numberedListIndex: number): Promise<RB>;
+}

package/types/src/context/BlockNoteContext.d.ts

@@ -0,0 +1,59 @@
+import { Block, BlockSchema, BlockSchemaFromSpecs, BlockSpecs, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, InlineContentSchema, InlineContentSchemaFromSpecs, InlineContentSpecs, StyleSchema, StyleSchemaFromSpecs, StyleSpecs, defaultBlockSpecs, defaultInlineContentSpecs, defaultStyleSpecs } from "@blocknote/core";
+import { Schema as PMSchema } from "@tiptap/pm/model";
+import * as Y from "yjs";
+export type BlockNoteEditorOptions<BSpecs extends BlockSpecs, ISpecs extends InlineContentSpecs, SSpecs extends StyleSpecs> = {
+    blockSpecs: BSpecs;
+    styleSpecs: SSpecs;
+    inlineContentSpecs: ISpecs;
+};
+export declare class BlockNoteContext<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
+    readonly blockSchema: BSchema;
+    readonly inlineContentSchema: ISchema;
+    readonly styleSchema: SSchema;
+    readonly blockImplementations: BlockSpecs;
+    readonly inlineContentImplementations: InlineContentSpecs;
+    readonly styleImplementations: StyleSpecs;
+    readonly pmSchema: PMSchema;
+    static create<BSpecs extends BlockSpecs = typeof defaultBlockSpecs, ISpecs extends InlineContentSpecs = typeof defaultInlineContentSpecs, SSpecs extends StyleSpecs = typeof defaultStyleSpecs>(options?: Partial<BlockNoteEditorOptions<BSpecs, ISpecs, SSpecs>>): BlockNoteContext<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>;
+    private constructor();
+    prosemirrorJSONToBlocks(json: any): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    yDocToBlocks(ydoc: Y.Doc, xmlFragment?: string): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    yXmlFragmentToBlocks(xmlFragment: Y.XmlFragment): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * Serializes blocks into an HTML string. To better conform to HTML standards, children of blocks which aren't list
+     * items are un-nested in the output HTML.
+     * @param blocks An array of blocks that should be serialized into HTML.
+     * @returns The blocks, serialized as an HTML string.
+     */
+    blocksToHTMLLossy(blocks: Block<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Serializes blocks into an HTML string in the format that it would be rendered by the editor.
+     *
+     * Use this method if you want to server-side render HTML (for example, a blog post that has been edited in BlockNote)
+     * and serve it to users without loading the editor on the client (i.e.: displaying the blog post)
+     */
+    blocksToBlockNoteStyleHTML(blocks: Block<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Parses blocks from an HTML string. Tries to create `Block` objects out of any HTML block-level elements, and
+     * `InlineNode` objects from any HTML inline elements, though not all element types are recognized. If BlockNote
+     * doesn't recognize an HTML element's tag, it will parse it as a paragraph or plain text.
+     * @param html The HTML string to parse blocks from.
+     * @returns The blocks parsed from the HTML string.
+     */
+    tryParseHTMLToBlocks(html: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+    /**
+     * Serializes blocks into a Markdown string. The output is simplified as Markdown does not support all features of
+     * BlockNote - children of blocks which aren't list items are un-nested and certain styles are removed.
+     * @param blocks An array of blocks that should be serialized into Markdown.
+     * @returns The blocks, serialized as a Markdown string.
+     */
+    blocksToMarkdownLossy(blocks: Block<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Creates a list of blocks from a Markdown string. Tries to create `Block` and `InlineNode` objects based on
+     * Markdown syntax, though not all symbols are recognized. If BlockNote doesn't recognize a symbol, it will parse it
+     * as text.
+     * @param markdown The Markdown string to parse blocks from.
+     * @returns The blocks parsed from the Markdown string.
+     */
+    tryParseMarkdownToBlocks(markdown: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+}

package/types/src/context/BlockNoteContext.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/src/context/ServerBlockNoteEditor.d.ts

@@ -0,0 +1,137 @@
+import { Block, BlockNoteEditor, BlockNoteEditorOptions, BlockSchema, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, InlineContentSchema, PartialBlock, StyleSchema } from "@blocknote/core";
+import { Node } from "@tiptap/pm/model";
+import * as React from "react";
+import type * as Y from "yjs";
+/**
+ * Use the ServerBlockNoteEditor to interact with BlockNote documents in a server (nodejs) environment.
+ */
+export declare class ServerBlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
+    /**
+     * Internal BlockNoteEditor (not recommended to use directly, use the methods of this class instead)
+     */
+    readonly editor: BlockNoteEditor<BSchema, ISchema, SSchema>;
+    /**
+     * We currently use a JSDOM instance to mock document and window methods
+     *
+     * A possible improvement could be to make this:
+     * a) pluggable so other shims can be used as well
+     * b) obsolete, but for this all blocks should be React based and we need to remove all references to document / window
+     *    from the core / react package. (and even then, it's likely some custom blocks would still use document / window methods)
+     */
+    private jsdom;
+    /**
+     * Calls a function with mocking window and document using JSDOM
+     *
+     * We could make this obsolete by passing in a document / window object to the render / serialize methods of Blocks
+     */
+    _withJSDOM<T>(fn: () => Promise<T>): Promise<T>;
+    static create<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema>(options?: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>): ServerBlockNoteEditor<BSchema, ISchema, SSchema>;
+    protected constructor(options: Partial<BlockNoteEditorOptions<any, any, any>>);
+    /** PROSEMIRROR / BLOCKNOTE conversions */
+    /**
+     * Turn Prosemirror JSON to BlockNote style JSON
+     * @param json Prosemirror JSON
+     * @returns BlockNote style JSON
+     */
+    _prosemirrorNodeToBlocks(pmNode: Node): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * Turn Prosemirror JSON to BlockNote style JSON
+     * @param json Prosemirror JSON
+     * @returns BlockNote style JSON
+     */
+    _prosemirrorJSONToBlocks(json: any): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * Turn BlockNote JSON to Prosemirror node / state
+     * @param blocks BlockNote blocks
+     * @returns Prosemirror root node
+     */
+    _blocksToProsemirrorNode(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Node;
+    /** YJS / BLOCKNOTE conversions */
+    /**
+     * Turn a Y.XmlFragment collaborative doc into a BlockNote document (BlockNote style JSON of all blocks)
+     * @returns BlockNote document (BlockNote style JSON of all blocks)
+     */
+    yXmlFragmentToBlocks(xmlFragment: Y.XmlFragment): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * Convert blocks to a Y.XmlFragment
+     *
+     * This can be used when importing existing content to Y.Doc for the first time,
+     * note that this should not be used to rehydrate a Y.Doc from a database once
+     * collaboration has begun as all history will be lost
+     *
+     * @param blocks the blocks to convert
+     * @returns Y.XmlFragment
+     */
+    blocksToYXmlFragment(blocks: Block<BSchema, ISchema, SSchema>[], xmlFragment?: Y.XmlFragment): Y.XmlFragment;
+    /**
+     * Turn a Y.Doc collaborative doc into a BlockNote document (BlockNote style JSON of all blocks)
+     * @returns BlockNote document (BlockNote style JSON of all blocks)
+     */
+    yDocToBlocks(ydoc: Y.Doc, xmlFragment?: string): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * This can be used when importing existing content to Y.Doc for the first time,
+     * note that this should not be used to rehydrate a Y.Doc from a database once
+     * collaboration has begun as all history will be lost
+     *
+     * @param blocks
+     */
+    blocksToYDoc(blocks: PartialBlock<BSchema, ISchema, SSchema>[], xmlFragment?: string): Y.Doc;
+    /** HTML / BLOCKNOTE conversions */
+    /**
+     * Exports blocks into a simplified HTML string. To better conform to HTML standards, children of blocks which aren't list
+     * items are un-nested in the output HTML.
+     *
+     * @param blocks An array of blocks that should be serialized into HTML.
+     * @returns The blocks, serialized as an HTML string.
+     */
+    blocksToHTMLLossy(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Serializes blocks into an HTML string in the format that would normally be rendered by the editor.
+     *
+     * Use this method if you want to server-side render HTML (for example, a blog post that has been edited in BlockNote)
+     * and serve it to users without loading the editor on the client (i.e.: displaying the blog post)
+     *
+     * @param blocks An array of blocks that should be serialized into HTML.
+     * @returns The blocks, serialized as an HTML string.
+     */
+    blocksToFullHTML(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Parses blocks from an HTML string. Tries to create `Block` objects out of any HTML block-level elements, and
+     * `InlineNode` objects from any HTML inline elements, though not all element types are recognized. If BlockNote
+     * doesn't recognize an HTML element's tag, it will parse it as a paragraph or plain text.
+     * @param html The HTML string to parse blocks from.
+     * @returns The blocks parsed from the HTML string.
+     */
+    tryParseHTMLToBlocks(html: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+    /** MARKDOWN / BLOCKNOTE conversions */
+    /**
+     * Serializes blocks into a Markdown string. The output is simplified as Markdown does not support all features of
+     * BlockNote - children of blocks which aren't list items are un-nested and certain styles are removed.
+     * @param blocks An array of blocks that should be serialized into Markdown.
+     * @returns The blocks, serialized as a Markdown string.
+     */
+    blocksToMarkdownLossy(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Creates a list of blocks from a Markdown string. Tries to create `Block` and `InlineNode` objects based on
+     * Markdown syntax, though not all symbols are recognized. If BlockNote doesn't recognize a symbol, it will parse it
+     * as text.
+     * @param markdown The Markdown string to parse blocks from.
+     * @returns The blocks parsed from the Markdown string.
+     */
+    tryParseMarkdownToBlocks(markdown: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+    /**
+     * If you're using React Context in your blocks, you can use this method to wrap editor calls for importing / exporting / block manipulation
+     * with the React Context Provider.
+     *
+     * Example:
+     *
+     * ```tsx
+        const html = await editor.withReactContext(
+        ({ children }) => (
+          <YourContext.Provider value={true}>{children}</YourContext.Provider>
+        ),
+        async () => editor.blocksToFullHTML(blocks)
+      );
+     */
+    withReactContext<T>(comp: React.FC<any>, fn: () => Promise<T>): Promise<T>;
+}

package/types/src/context/ServerBlockNoteEditor.test.d.ts

@@ -0,0 +1 @@
+export {};