@blocknote/core 0.38.0 → 0.39.1-capitol

package/src/util/topo-sort.ts

@@ -0,0 +1,160 @@
+/**
+ * Instead of depending on the NPM package, we vendor this file from https://github.com/n1ru4l/toposort/blob/main/src/toposort.ts (MIT)
+ *
+ * There was a recent publish, despite not having been updated in 2 years, which is suspicious.
+ *
+ * This file is also simple enough that we can maintain it ourselves.
+ */
+
+export type DirectedAcyclicGraph = Map<string, Iterable<string>>;
+export type DependencyGraph = DirectedAcyclicGraph;
+
+export type TaskList = Array<Set<string>>;
+
+// Add more specific types for better type safety
+export type NodeId = string;
+export type DependencyMap = Map<NodeId, Set<NodeId>>;
+
+export function toposort(dag: DirectedAcyclicGraph): TaskList {
+  const inDegrees = countInDegrees(dag);
+
+  let { roots, nonRoots } = getRootsAndNonRoots(inDegrees);
+
+  const sorted: TaskList = [];
+
+  while (roots.size) {
+    sorted.push(roots);
+
+    const newRoots = new Set<NodeId>();
+    for (const root of roots) {
+      const dependents = dag.get(root);
+      if (!dependents) {
+        // Handle case where node has no dependents
+        continue;
+      }
+
+      for (const dependent of dependents) {
+        const currentDegree = inDegrees.get(dependent);
+        if (currentDegree === undefined) {
+          // Handle case where dependent node is not in inDegrees
+          continue;
+        }
+
+        const newDegree = currentDegree - 1;
+        inDegrees.set(dependent, newDegree);
+
+        if (newDegree === 0) {
+          newRoots.add(dependent);
+        }
+      }
+    }
+
+    roots = newRoots;
+  }
+  nonRoots = getRootsAndNonRoots(inDegrees).nonRoots;
+
+  if (nonRoots.size) {
+    throw new Error(
+      `Cycle(s) detected; toposort only works on acyclic graphs. Cyclic nodes: ${Array.from(nonRoots).join(", ")}`,
+    );
+  }
+
+  return sorted;
+}
+
+export function toposortReverse(deps: DependencyGraph): TaskList {
+  const dag = reverse(deps);
+  return toposort(dag);
+}
+
+type InDegrees = Map<NodeId, number>;
+
+function countInDegrees(dag: DirectedAcyclicGraph): InDegrees {
+  const counts: InDegrees = new Map();
+
+  for (const [vx, dependents] of dag.entries()) {
+    // Initialize count for current node if not present
+    if (!counts.has(vx)) {
+      counts.set(vx, 0);
+    }
+
+    for (const dependent of dependents) {
+      const currentCount = counts.get(dependent) ?? 0;
+      counts.set(dependent, currentCount + 1);
+    }
+  }
+
+  return counts;
+}
+
+function getRootsAndNonRoots(counts: InDegrees) {
+  const roots = new Set<NodeId>();
+  const nonRoots = new Set<NodeId>();
+
+  for (const [id, deg] of counts.entries()) {
+    if (deg === 0) {
+      roots.add(id);
+    } else {
+      nonRoots.add(id);
+    }
+  }
+
+  return { roots, nonRoots };
+}
+
+function reverse(deps: DirectedAcyclicGraph): DependencyGraph {
+  const reversedDeps: DependencyMap = new Map();
+
+  for (const [name, dependsOn] of deps.entries()) {
+    // Ensure the source node exists in the reversed map
+    if (!reversedDeps.has(name)) {
+      reversedDeps.set(name, new Set());
+    }
+
+    for (const dependsOnName of dependsOn) {
+      if (!reversedDeps.has(dependsOnName)) {
+        reversedDeps.set(dependsOnName, new Set());
+      }
+      reversedDeps.get(dependsOnName)!.add(name);
+    }
+  }
+
+  return reversedDeps;
+}
+
+export function createDependencyGraph(): DependencyMap {
+  return new Map();
+}
+
+export function addDependency(
+  graph: DependencyMap,
+  from: NodeId,
+  to: NodeId,
+): DependencyMap {
+  if (!graph.has(from)) {
+    graph.set(from, new Set());
+  }
+  graph.get(from)!.add(to);
+  return graph;
+}
+
+export function removeDependency(
+  graph: DependencyMap,
+  from: NodeId,
+  to: NodeId,
+): boolean {
+  const dependents = graph.get(from);
+  if (!dependents) {
+    return false;
+  }
+  return dependents.delete(to);
+}
+
+export function hasDependency(
+  graph: DependencyMap,
+  from: NodeId,
+  to: NodeId,
+): boolean {
+  const dependents = graph.get(from);
+  return dependents ? dependents.has(to) : false;
+}

package/types/src/api/blockManipulation/commands/splitBlock/splitBlock.d.ts

@@ -1,5 +1,6 @@
-import { EditorState } from "prosemirror-state";
+import { EditorState, Transaction } from "prosemirror-state";
 export declare const splitBlockCommand: (posInBlock: number, keepType?: boolean, keepProps?: boolean) => ({ state, dispatch, }: {
     state: EditorState;
     dispatch: ((args?: any) => any) | undefined;
 }) => boolean;
+export declare const splitBlockTr: (tr: Transaction, posInBlock: number, keepType?: boolean, keepProps?: boolean) => boolean;

package/types/src/api/blockManipulation/selections/selection.d.ts

@@ -5,7 +5,7 @@ import { BlockIdentifier, BlockSchema, InlineContentSchema, StyleSchema } from "
 export declare function getSelection<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(tr: Transaction): Selection<BSchema, I, S> | undefined;
 export declare function setSelection(tr: Transaction, startBlock: BlockIdentifier, endBlock: BlockIdentifier): void;
 export declare function getSelectionCutBlocks(tr: Transaction): {
-    blocks: Block<Record<string, import("../../../index.js").BlockConfig>, InlineContentSchema, StyleSchema>[];
+    blocks: Block<Record<string, import("../../../index.js").BlockConfig<string, import("../../../index.js").PropSchema, "inline" | "none" | "table">>, InlineContentSchema, StyleSchema>[];
     blockCutAtStart: string | undefined;
     blockCutAtEnd: string | undefined;
     _meta: {