refactor: stash into cached schema property

Author: nperez0111

packages/core/src/api/blockManipulation/commands/insertBlocks/insertBlocks.test.ts

@@ -15,15 +15,7 @@ function insertBlocks(
   placement: "before" | "after" = "before"
 ) {
   return editor.transact((tr) =>
-    insertBlocksTr(
-      tr,
-      editor.pmSchema,
-      editor.schema,
-      blocksToInsert,
-      referenceBlock,
-      placement,
-      editor.blockCache
-    )
+    insertBlocksTr(tr, blocksToInsert, referenceBlock, placement)
   );
 }
 

packages/core/src/api/blockManipulation/commands/insertBlocks/insertBlocks.ts

@@ -1,40 +1,36 @@
-import { Fragment, Node, Schema, Slice } from "prosemirror-model";
+import { Fragment, Slice } from "prosemirror-model";
 
 import { Block, PartialBlock } from "../../../../blocks/defaultBlocks.js";
-import type { BlockCache } from "../../../../editor/BlockNoteEditor";
 import {
   BlockIdentifier,
   BlockSchema,
   InlineContentSchema,
   StyleSchema,
 } from "../../../../schema/index.js";
-import { blockToNode } from "../../../nodeConversions/blockToNode.js";
-import { nodeToBlock } from "../../../nodeConversions/nodeToBlock.js";
+import { simpleBlockToNode } from "../../../nodeConversions/blockToNode.js";
+import { simpleNodeToBlock } from "../../../nodeConversions/nodeToBlock.js";
 import { getNodeById } from "../../../nodeUtil.js";
 import { ReplaceStep } from "prosemirror-transform";
 import type { Transaction } from "prosemirror-state";
-import type { BlockNoteSchema } from "../../../../editor/BlockNoteSchema.js";
+import { getSchemaForTransaction } from "../../../pmUtil.js";
 
 export function insertBlocks<
   BSchema extends BlockSchema,
   I extends InlineContentSchema,
   S extends StyleSchema
 >(
   tr: Transaction,
-  pmSchema: Schema,
-  schema: BlockNoteSchema<BSchema, I, S>,
   blocksToInsert: PartialBlock<BSchema, I, S>[],
   referenceBlock: BlockIdentifier,
-  placement: "before" | "after" = "before",
-  blockCache?: BlockCache
+  placement: "before" | "after" = "before"
 ): Block<BSchema, I, S>[] {
   const id =
     typeof referenceBlock === "string" ? referenceBlock : referenceBlock.id;
+  const schema = getSchemaForTransaction(tr);
 
-  const nodesToInsert: Node[] = [];
-  for (const blockSpec of blocksToInsert) {
-    nodesToInsert.push(blockToNode(blockSpec, pmSchema, schema.styleSchema));
-  }
+  const nodesToInsert = blocksToInsert.map((block) =>
+    simpleBlockToNode(block, schema)
+  );
 
   const posInfo = getNodeById(id, tr.doc);
   if (!posInfo) {
@@ -52,18 +48,9 @@ export function insertBlocks<
 
   // Now that the `PartialBlock`s have been converted to nodes, we can
   // re-convert them into full `Block`s.
-  const insertedBlocks: Block<BSchema, I, S>[] = [];
-  for (const node of nodesToInsert) {
-    insertedBlocks.push(
-      nodeToBlock(
-        node,
-        schema.blockSchema,
-        schema.inlineContentSchema,
-        schema.styleSchema,
-        blockCache
-      )
-    );
-  }
+  const insertedBlocks = nodesToInsert.map((node) =>
+    simpleNodeToBlock(node, schema)
+  );
 
   return insertedBlocks;
 }

packages/core/src/api/nodeConversions/blockToNode.ts

@@ -19,6 +19,7 @@ import {
 import { getColspan, isPartialTableCell } from "../../util/table.js";
 import { UnreachableCaseError } from "../../util/typescript.js";
 import { getAbsoluteTableCells } from "../blockManipulation/tables/tables.js";
+import { getStyleSchemaForSchema } from "../pmUtil.js";
 
 /**
  * Convert a StyledText inline element to a
@@ -300,6 +301,13 @@ function blockOrInlineContentToContentNode(
   return contentNode;
 }
 
+export function simpleBlockToNode(
+  block: PartialBlock<any, any, any>,
+  schema: Schema
+) {
+  return blockToNode(block, schema, getStyleSchemaForSchema(schema));
+}
+
 /**
  * Converts a BlockNote block to a Prosemirror node.
  */

packages/core/src/api/nodeConversions/nodeToBlock.ts

@@ -1,4 +1,4 @@
-import { Mark, Node } from "@tiptap/pm/model";
+import { Mark, Node, Schema } from "@tiptap/pm/model";
 
 import UniqueID from "../../extensions/UniqueID/UniqueID.js";
 import type {
@@ -22,6 +22,9 @@ import {
 } from "../../schema/inlineContent/types.js";
 import { UnreachableCaseError } from "../../util/typescript.js";
 import type { BlockCache } from "../../editor/BlockNoteEditor.js";
+import { getBlockCacheForSchema, getStyleSchemaForSchema } from "../pmUtil.js";
+import { getInlineContentSchemaForSchema } from "../pmUtil.js";
+import { getBlockSchemaForSchema } from "../pmUtil.js";
 
 /**
  * Converts an internal (prosemirror) table node contentto a BlockNote Tablecontent
@@ -375,6 +378,19 @@ export function nodeToCustomInlineContent<
   return ic;
 }
 
+export function simpleNodeToBlock(
+  node: Node,
+  schema: Schema
+): Block<any, any, any> {
+  return nodeToBlock(
+    node,
+    getBlockSchemaForSchema(schema),
+    getInlineContentSchemaForSchema(schema),
+    getStyleSchemaForSchema(schema),
+    getBlockCacheForSchema(schema)
+  );
+}
+
 /**
  * Convert a Prosemirror node to a BlockNote block.
  *

packages/core/src/api/pmUtil.ts

@@ -0,0 +1,32 @@
+import type { Schema } from "prosemirror-model";
+import type { Transaction } from "prosemirror-state";
+import type { BlockNoteEditor } from "../editor/BlockNoteEditor.js";
+import type { BlockSchema } from "../schema/blocks/types.js";
+import type { InlineContentSchema } from "../schema/inlineContent/types.js";
+import type { StyleSchema } from "../schema/styles/types.js";
+
+export function getSchemaForTransaction(tr: Transaction) {
+  return tr.doc.type.schema;
+}
+
+export function getBlockNoteEditorForSchema(
+  schema: Schema
+): BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema> {
+  return schema.cached.blockNoteEditor;
+}
+
+export function getBlockSchemaForSchema(schema: Schema) {
+  return getBlockNoteEditorForSchema(schema).schema.blockSchema;
+}
+
+export function getInlineContentSchemaForSchema(schema: Schema) {
+  return getBlockNoteEditorForSchema(schema).schema.inlineContentSchema;
+}
+
+export function getStyleSchemaForSchema(schema: Schema) {
+  return getBlockNoteEditorForSchema(schema).schema.styleSchema;
+}
+
+export function getBlockCacheForSchema(schema: Schema) {
+  return getBlockNoteEditorForSchema(schema).blockCache;
+}

packages/core/src/editor/BlockNoteEditor.ts

@@ -728,6 +728,7 @@ export class BlockNoteEditor<
       // but we still need the schema
       this.pmSchema = getSchema(tiptapOptions.extensions!);
     }
+    this.pmSchema.cached.blockNoteEditor = this;
     this.emit("create");
   }