@blocknote/core 0.15.11 → 0.17.0

package/src/api/exporters/copyExtension.ts

@@ -1,164 +0,0 @@
-import { Extension } from "@tiptap/core";
-import { Node } from "prosemirror-model";
-import { NodeSelection, Plugin } from "prosemirror-state";
-
-import { EditorView } from "prosemirror-view";
-import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
-import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
-import { initializeESMDependencies } from "../../util/esmDependencies";
-import { createExternalHTMLExporter } from "./html/externalHTMLExporter";
-import { createInternalHTMLSerializer } from "./html/internalHTMLSerializer";
-import { cleanHTMLToMarkdown } from "./markdown/markdownExporter";
-
-async function selectedFragmentToHTML<
-  BSchema extends BlockSchema,
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  view: EditorView,
-  editor: BlockNoteEditor<BSchema, I, S>
-): Promise<{
-  internalHTML: string;
-  externalHTML: string;
-  plainText: string;
-}> {
-  const selectedFragment = view.state.selection.content().content;
-
-  const internalHTMLSerializer = createInternalHTMLSerializer(
-    view.state.schema,
-    editor
-  );
-  const internalHTML = internalHTMLSerializer.serializeProseMirrorFragment(
-    selectedFragment,
-    {}
-  );
-
-  await initializeESMDependencies();
-  const externalHTMLExporter = createExternalHTMLExporter(
-    view.state.schema,
-    editor
-  );
-  const externalHTML = externalHTMLExporter.exportProseMirrorFragment(
-    selectedFragment,
-    {}
-  );
-
-  const plainText = await cleanHTMLToMarkdown(externalHTML);
-
-  return { internalHTML, externalHTML, plainText };
-}
-
-const copyToClipboard = <
-  BSchema extends BlockSchema,
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  editor: BlockNoteEditor<BSchema, I, S>,
-  view: EditorView,
-  event: ClipboardEvent
-) => {
-  // Stops the default browser copy behaviour.
-  event.preventDefault();
-  event.clipboardData!.clearData();
-
-  // Checks if a `blockContent` node is being copied and expands
-  // the selection to the parent `blockContainer` node. This is
-  // for the use-case in which only a block without content is
-  // selected, e.g. an image block.
-  if (
-    "node" in view.state.selection &&
-    (view.state.selection.node as Node).type.spec.group === "blockContent"
-  ) {
-    editor.dispatch(
-      editor._tiptapEditor.state.tr.setSelection(
-        new NodeSelection(view.state.doc.resolve(view.state.selection.from - 1))
-      )
-    );
-  }
-
-  (async () => {
-    const { internalHTML, externalHTML, plainText } =
-      await selectedFragmentToHTML(view, editor);
-
-    // TODO: Writing to other MIME types not working in Safari for
-    //  some reason.
-    event.clipboardData!.setData("blocknote/html", internalHTML);
-    event.clipboardData!.setData("text/html", externalHTML);
-    event.clipboardData!.setData("text/plain", plainText);
-  })();
-};
-
-export const createCopyToClipboardExtension = <
-  BSchema extends BlockSchema,
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  editor: BlockNoteEditor<BSchema, I, S>
-) =>
-  Extension.create<{ editor: BlockNoteEditor<BSchema, I, S> }, undefined>({
-    name: "copyToClipboard",
-    addProseMirrorPlugins() {
-      return [
-        new Plugin({
-          props: {
-            handleDOMEvents: {
-              copy(view, event) {
-                copyToClipboard(editor, view, event);
-                // Prevent default PM handler to be called
-                return true;
-              },
-              cut(view, event) {
-                copyToClipboard(editor, view, event);
-                view.dispatch(view.state.tr.deleteSelection());
-                // Prevent default PM handler to be called
-                return true;
-              },
-              // This is for the use-case in which only a block without content
-              // is selected, e.g. an image block, and dragged (not using the
-              // drag handle).
-              dragstart(view, event) {
-                // Checks if a `NodeSelection` is active.
-                if (!("node" in view.state.selection)) {
-                  return;
-                }
-
-                // Checks if a `blockContent` node is being dragged.
-                if (
-                  (view.state.selection.node as Node).type.spec.group !==
-                  "blockContent"
-                ) {
-                  return;
-                }
-
-                // Expands the selection to the parent `blockContainer` node.
-                editor.dispatch(
-                  editor._tiptapEditor.state.tr.setSelection(
-                    new NodeSelection(
-                      view.state.doc.resolve(view.state.selection.from - 1)
-                    )
-                  )
-                );
-
-                // Stops the default browser drag start behaviour.
-                event.preventDefault();
-                event.dataTransfer!.clearData();
-
-                (async () => {
-                  const { internalHTML, externalHTML, plainText } =
-                    await selectedFragmentToHTML(view, editor);
-
-                  // TODO: Writing to other MIME types not working in Safari for
-                  //  some reason.
-                  event.dataTransfer!.setData("blocknote/html", internalHTML);
-                  event.dataTransfer!.setData("text/html", externalHTML);
-                  event.dataTransfer!.setData("text/plain", plainText);
-                })();
-                // Prevent default PM handler to be called
-                return true;
-              },
-            },
-          },
-        }),
-      ];
-    },
-  });

package/src/api/exporters/html/__snapshots_fragment_edge_cases__/selectionLeavesBlockChildren.html

@@ -1 +0,0 @@
-<p>Nested Paragraph 1</p><p>Nested Paragraph 2</p><p>Nested Paragraph 3</p><p>Paragraph 2</p>

package/src/api/exporters/html/__snapshots_fragment_edge_cases__/selectionSpansBlocksChildren.html

@@ -1 +0,0 @@
-<p>Nested Paragraph 1</p><p>Nested Paragraph 2</p><p>Nested Paragraph 3</p><p>Paragraph 2</p><p>Nested Paragraph 1</p><p>Nested Paragraph 2</p><p>Nested Paragraph 3</p>

package/src/api/exporters/html/util/sharedHTMLConversion.ts

@@ -1,130 +0,0 @@
-import { DOMSerializer, Fragment, Node } from "prosemirror-model";
-
-import type { BlockNoteEditor } from "../../../../editor/BlockNoteEditor";
-import {
-  BlockSchema,
-  InlineContentSchema,
-  StyleSchema,
-} from "../../../../schema";
-import { nodeToBlock } from "../../../nodeConversions/nodeConversions";
-
-function doc(options: { document?: Document }) {
-  return options.document || window.document;
-}
-
-// Used to implement `serializeNodeInner` for the `internalHTMLSerializer` and
-// `externalHTMLExporter`. Changes how the content of `blockContainer` nodes is
-// serialized vs the default `DOMSerializer` implementation. For the
-// `blockContent` node, the `toInternalHTML` or `toExternalHTML` function of its
-// corresponding block is used for serialization instead of the node's
-// `renderHTML` method.
-export const serializeNodeInner = <
-  BSchema extends BlockSchema,
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  node: Node,
-  options: { document?: Document },
-  serializer: DOMSerializer,
-  editor: BlockNoteEditor<BSchema, I, S>,
-  toExternalHTML: boolean
-) => {
-  if (!serializer.nodes[node.type.name]) {
-    throw new Error("Serializer is missing a node type: " + node.type.name);
-  }
-
-  const { dom, contentDOM } = DOMSerializer.renderSpec(
-    doc(options),
-    serializer.nodes[node.type.name](node)
-  );
-
-  if (contentDOM) {
-    if (node.isLeaf) {
-      throw new RangeError("Content hole not allowed in a leaf node spec");
-    }
-
-    // Handles converting `blockContainer` nodes to HTML.
-    if (node.type.name === "blockContainer") {
-      const blockContentNode =
-        node.childCount > 0 &&
-        node.firstChild!.type.spec.group === "blockContent"
-          ? node.firstChild!
-          : undefined;
-      const blockGroupNode =
-        node.childCount > 0 && node.lastChild!.type.spec.group === "blockGroup"
-          ? node.lastChild!
-          : undefined;
-
-      // Converts `blockContent` node using the custom `blockSpec`'s
-      // `toExternalHTML` or `toInternalHTML` function.
-      // Note: While `blockContainer` nodes should always contain a
-      // `blockContent` node according to the schema, PM Fragments don't always
-      // conform to the schema. This is unintuitive but important as it occurs
-      // when copying only nested blocks.
-      if (blockContentNode !== undefined) {
-        const impl =
-          editor.blockImplementations[blockContentNode.type.name]
-            .implementation;
-        const toHTML = toExternalHTML
-          ? impl.toExternalHTML
-          : impl.toInternalHTML;
-        const blockContent = toHTML(
-          nodeToBlock(
-            node,
-            editor.schema.blockSchema,
-            editor.schema.inlineContentSchema,
-            editor.schema.styleSchema,
-            editor.blockCache
-          ),
-          editor as any
-        );
-
-        // Converts inline nodes in the `blockContent` node's content to HTML
-        // using their `renderHTML` methods.
-        if (blockContent.contentDOM !== undefined) {
-          if (node.isLeaf) {
-            throw new RangeError(
-              "Content hole not allowed in a leaf node spec"
-            );
-          }
-
-          blockContent.contentDOM.appendChild(
-            serializer.serializeFragment(blockContentNode.content, options)
-          );
-        }
-
-        contentDOM.appendChild(blockContent.dom);
-      }
-
-      // Converts `blockGroup` node to HTML using its `renderHTML` method.
-      if (blockGroupNode !== undefined) {
-        serializer.serializeFragment(
-          Fragment.from(blockGroupNode),
-          options,
-          contentDOM
-        );
-      }
-    } else {
-      // Converts the node normally, i.e. using its `renderHTML method`.
-      serializer.serializeFragment(node.content, options, contentDOM);
-    }
-  }
-
-  return dom as HTMLElement;
-};
-
-// Used to implement `serializeProseMirrorFragment` for the
-// `internalHTMLSerializer` and `externalHTMLExporter`. Does basically the same
-// thing as `serializer.serializeFragment`, but takes fewer arguments and
-// returns a string instead, to make it easier to use.
-export const serializeProseMirrorFragment = (
-  fragment: Fragment,
-  serializer: DOMSerializer,
-  options?: { document?: Document }
-) => {
-  const internalHTML = serializer.serializeFragment(fragment, options);
-  const parent = document.createElement("div");
-  parent.appendChild(internalHTML);
-
-  return parent.innerHTML;
-};

package/src/api/exporters/html/util/simplifyBlocksRehypePlugin.ts

@@ -1,218 +0,0 @@
-import { Element as HASTElement, Parent as HASTParent } from "hast";
-import { esmDependencies } from "../../../../util/esmDependencies";
-
-type SimplifyBlocksOptions = {
-  orderedListItemBlockTypes: Set<string>;
-  unorderedListItemBlockTypes: Set<string>;
-};
-
-function addAttributesAndRemoveClasses(
-  element: HASTElement,
-  attributes: Record<string, unknown>
-) {
-  // Removes all BlockNote specific class names.
-  const className =
-    ((element.properties?.className as string[]) || []).filter(
-      (className) => !className.startsWith("bn-")
-    ) || [];
-  // Adds all block props as data attributes.
-  element.properties = {
-    ...element.properties,
-    ...attributes,
-    className: className.length > 0 ? className : undefined,
-  };
-}
-
-/**
- * Rehype plugin which converts the HTML output string rendered by BlockNote into a simplified structure which better
- * follows HTML standards. It does several things:
- * - Removes all block related div elements, leaving only the actual content inside the block.
- * - Lifts nested blocks to a higher level for all block types that don't represent list items.
- * - Wraps blocks which represent list items in corresponding ul/ol HTML elements and restructures them to comply
- * with HTML list structure.
- * @param options Options for specifying which block types represent ordered and unordered list items.
- */
-export function simplifyBlocks(options: SimplifyBlocksOptions) {
-  const deps = esmDependencies;
-
-  if (!deps) {
-    throw new Error(
-      "simplifyBlocks requires ESM dependencies to be initialized"
-    );
-  }
-
-  const listItemBlockTypes = new Set<string>([
-    ...options.orderedListItemBlockTypes,
-    ...options.unorderedListItemBlockTypes,
-  ]);
-
-  const simplifyBlocksHelper = (tree: HASTParent) => {
-    // Checks whether blocks in the tree are wrapped by a parent `blockGroup`
-    // element, in which case the `blockGroup`'s children are lifted out, and it
-    // is removed.
-    if (
-      tree.children.length === 1 &&
-      (tree.children[0] as HASTElement).properties?.["dataNodeType"] ===
-        "blockGroup"
-    ) {
-      const blockGroup = tree.children[0] as HASTElement;
-      tree.children.pop();
-      tree.children.push(...blockGroup.children);
-    }
-
-    let numChildElements = tree.children.length;
-    let activeList: HASTElement | undefined;
-
-    for (let i = 0; i < numChildElements; i++) {
-      const blockOuter = tree.children[i] as HASTElement;
-      const blockContainer = blockOuter.children[0] as HASTElement;
-      const blockContent = blockContainer.children.find((child) => {
-        const properties = (child as HASTElement).properties;
-        const classNames = properties?.["className"] as string[] | undefined;
-
-        return classNames?.includes("bn-block-content");
-      }) as HASTElement | undefined;
-      const blockGroup = blockContainer.children.find((child) => {
-        const properties = (child as HASTElement).properties;
-        const classNames = properties?.["className"] as string[] | undefined;
-
-        return classNames?.includes("bn-block-group");
-      }) as HASTElement | undefined;
-
-      // Saves the data attributes of the block container, excluding the block
-      // ID and node type as we're removing the block structure. This means that
-      // only attributes for the block's props are saved.
-      const blockContainerDataAttributes = Object.fromEntries(
-        Object.entries(blockContainer.properties || {}).filter(
-          ([key]) =>
-            key.startsWith("data") && key !== "dataId" && key !== "dataNodeType"
-        )
-      );
-      // Saves the data attributes of the block content, excluding the block
-      // content type as we're removing the block structure. This means that
-      // only attributes for the block's props are saved.
-      const blockContentDataAttributes = Object.fromEntries(
-        Object.entries(blockContent?.properties || {}).filter(
-          ([key]) =>
-            key.startsWith("data") &&
-            key !== "dataContentType" &&
-            key !== "dataFileBlock" &&
-            key !== "dataNodeViewWrapper" &&
-            key !== "dataEditable"
-        )
-      );
-      // All the block's props as data attributes.
-      const blockPropsDataAttributes = {
-        ...blockContainerDataAttributes,
-        ...blockContentDataAttributes,
-      };
-
-      // When the selection starts in a nested block, the Fragment from it omits
-      // the `blockContent` node of the parent `blockContainer` if it's not also
-      // included in the selection. This is because ProseMirror preserves the
-      // nesting hierarchy of the nested nodes, even if their ancestors aren't
-      // fully selected. In this case, we just lift the child `blockContainer`
-      // nodes up.
-      // NOTE: This only happens for the first `blockContainer`, since to get to
-      // any nested blocks later in the document, the selection must also
-      // include their parents.
-      if (!blockContent) {
-        tree.children.splice(i, 1, ...blockGroup!.children);
-        simplifyBlocksHelper(tree);
-
-        return;
-      }
-
-      const isListItemBlock = listItemBlockTypes.has(
-        blockContent.properties!["dataContentType"] as string
-      );
-
-      const listItemBlockType = isListItemBlock
-        ? options.orderedListItemBlockTypes.has(
-            blockContent.properties!["dataContentType"] as string
-          )
-          ? "ol"
-          : "ul"
-        : null;
-
-      // Plugin runs recursively to process nested blocks.
-      if (blockGroup) {
-        simplifyBlocksHelper(blockGroup);
-      }
-
-      // Checks that there is an active list, but the block can't be added to it as it's of a different type.
-      if (activeList && activeList.tagName !== listItemBlockType) {
-        // Blocks that were copied into the list are removed and the list is inserted in their place.
-        tree.children.splice(
-          i - activeList.children.length,
-          activeList.children.length,
-          activeList
-        );
-
-        // Updates the current index and number of child elements.
-        const numElementsRemoved = activeList.children.length - 1;
-        i -= numElementsRemoved;
-        numChildElements -= numElementsRemoved;
-
-        activeList = undefined;
-      }
-
-      // Checks if the block represents a list item.
-      if (isListItemBlock) {
-        // Checks if a list isn't already active. We don't have to check if the block and the list are of the same
-        // type as this was already done earlier.
-        if (!activeList) {
-          // Creates a new list element to represent an active list.
-          activeList = deps.hastUtilFromDom.fromDom(
-            document.createElement(listItemBlockType!)
-          ) as HASTElement;
-        }
-
-        // Creates a new list item element to represent the block.
-        const listItemElement = deps.hastUtilFromDom.fromDom(
-          document.createElement("li")
-        ) as HASTElement;
-
-        // Adds only the content inside the block to the active list.
-        listItemElement.children.push(...blockContent.children);
-        // Nested blocks have already been processed in the recursive function call, so the resulting elements are
-        // also added to the active list.
-        if (blockGroup) {
-          listItemElement.children.push(...blockGroup.children);
-        }
-
-        // Adds the list item representing the block to the active list.
-        activeList.children.push(listItemElement);
-      } else if (blockGroup) {
-        // Lifts all children out of the current block, as only list items should allow nesting.
-        tree.children.splice(i + 1, 0, ...blockGroup.children);
-        // Replaces the block with only the content inside it.
-        const content = blockContent.children[0] as HASTElement;
-        addAttributesAndRemoveClasses(content, blockPropsDataAttributes);
-        tree.children[i] = content;
-
-        // Updates the current index and number of child elements.
-        const numElementsAdded = blockGroup.children.length;
-        i += numElementsAdded;
-        numChildElements += numElementsAdded;
-      } else {
-        // Replaces the block with only the content inside it.
-        const content = blockContent.children[0] as HASTElement;
-        addAttributesAndRemoveClasses(content, blockPropsDataAttributes);
-        tree.children[i] = content;
-      }
-    }
-
-    // Since the active list is only inserted after encountering a block which can't be added to it, there are cases
-    // where it remains un-inserted after processing all blocks, which are handled here.
-    if (activeList) {
-      tree.children.splice(
-        numChildElements - activeList.children.length,
-        activeList.children.length,
-        activeList
-      );
-    }
-  };
-
-  return simplifyBlocksHelper;
-}

package/src/api/getCurrentBlockContentType.ts

@@ -1,14 +0,0 @@
-import { Editor } from "@tiptap/core";
-import { getBlockInfoFromPos } from "./getBlockInfoFromPos";
-
-// Used to get the content type of the block that the text cursor is in. This is
-// a band-aid fix to prevent input rules and keyboard shortcuts from triggering
-// in tables, but really those should be extended to work with block selections.
-export const getCurrentBlockContentType = (editor: Editor) => {
-  const { contentType } = getBlockInfoFromPos(
-    editor.state.doc,
-    editor.state.selection.from
-  );
-
-  return contentType.spec.content;
-};