@monstermann/graph 0.0.0 → 0.2.0

package/dist/Graph/forEachEdge.d.mts

@@ -0,0 +1,52 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/forEachEdge.d.ts
+/**
+ * # forEachEdge
+ *
+ * ```ts
+ * function Graph.forEachEdge(
+ *     graph: Graph,
+ *     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     type: NodeType,
+ *     fn: (edge: EdgeData) => void,
+ * ): Graph
+ * ```
+ *
+ * Iterates over all edges of a specific type from a source node, executing a function for each edge. Returns the graph unchanged (for chaining).
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: { priority: number } };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Project", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "2" });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], { priority: 1 });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"], { priority: 2 });
+ *
+ * Graph.forEachEdge(g, ["Project", "1"], "Task", (edge) => {
+ *     console.log(edge.priority);
+ * });
+ * // Logs:
+ * // 1
+ * // 2
+ * ```
+ *
+ */
+declare function forEachEdge<N extends Node, E extends Edges<N>, N1 extends keyof Bimap<E> & NodeType<N>, N2 extends keyof Bimap<E>[N1] & NodeType<N>>(graph: Graph<N, E>, source: NodeIdentifier<N, N1>, type: N2, fn: (edge: NoInfer<Bimap<E>[N1][N2]>) => void): Graph<N, E>;
+//#endregion
+export { forEachEdge };

package/dist/Graph/forEachEdge.mjs

@@ -0,0 +1,56 @@
+import { parseNodeIdentifier } from "./internals/parseNodeIdentifier.mjs";
+
+//#region src/Graph/forEachEdge.ts
+/**
+* # forEachEdge
+*
+* ```ts
+* function Graph.forEachEdge(
+*     graph: Graph,
+*     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     type: NodeType,
+*     fn: (edge: EdgeData) => void,
+* ): Graph
+* ```
+*
+* Iterates over all edges of a specific type from a source node, executing a function for each edge. Returns the graph unchanged (for chaining).
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: { priority: number } };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Project", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "2" });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], { priority: 1 });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"], { priority: 2 });
+*
+* Graph.forEachEdge(g, ["Project", "1"], "Task", (edge) => {
+*     console.log(edge.priority);
+* });
+* // Logs:
+* // 1
+* // 2
+* ```
+*
+*/
+function forEachEdge(graph, source, type, fn) {
+	const [sourceType, sourceId] = parseNodeIdentifier(source);
+	for (const edge of graph.get("edges")?.get(sourceType)?.get(sourceId)?.get(type)?.values() ?? []) fn(edge);
+	return graph;
+}
+
+//#endregion
+export { forEachEdge };

package/dist/Graph/forEachNeighbor.d.mts

@@ -0,0 +1,52 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/forEachNeighbor.d.ts
+/**
+ * # forEachNeighbor
+ *
+ * ```ts
+ * function Graph.forEachNeighbor(
+ *     graph: Graph,
+ *     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     type: NodeType,
+ *     fn: (target: Node, edge: EdgeData, source: Node) => void,
+ * ): Graph
+ * ```
+ *
+ * Iterates over all neighbor nodes of a specific type, executing a function for each neighbor. The function receives the target node, edge data, and source node. Returns the graph unchanged (for chaining).
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string; name: string };
+ *
+ * type Edges = {
+ *     Project: { Task: { priority: number } };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Project", id: "1", name: "My Project" });
+ * g = Graph.setNode(g, { type: "Task", id: "1", title: "First Task" });
+ * g = Graph.setNode(g, { type: "Task", id: "2", title: "Second Task" });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], { priority: 1 });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"], { priority: 2 });
+ *
+ * Graph.forEachNeighbor(g, ["Project", "1"], "Task", (task, edge, project) => {
+ *     console.log(`${project.name}: ${task.title} (priority: ${edge.priority})`);
+ * });
+ * // Logs:
+ * // "My Project: First Task (priority: 1)"
+ * // "My Project: Second Task (priority: 2)"
+ * ```
+ *
+ */
+declare function forEachNeighbor<N extends Node, E extends Edges<N>, N1 extends NodeType<N>, N2 extends keyof Bimap<E>[N1] & NodeType<N>>(graph: Graph<N, E>, node: NodeIdentifier<N, N1>, type: N2, fn: (target: NoInfer<NodeOfType<N, N2>>, edge: NoInfer<Bimap<E>[N1][N2]>, source: NoInfer<NodeOfType<N, N1>>) => void): Graph<N, E>;
+//#endregion
+export { forEachNeighbor };

package/dist/Graph/forEachNeighbor.mjs

@@ -0,0 +1,59 @@
+import { getNode } from "./getNode.mjs";
+
+//#region src/Graph/forEachNeighbor.ts
+/**
+* # forEachNeighbor
+*
+* ```ts
+* function Graph.forEachNeighbor(
+*     graph: Graph,
+*     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     type: NodeType,
+*     fn: (target: Node, edge: EdgeData, source: Node) => void,
+* ): Graph
+* ```
+*
+* Iterates over all neighbor nodes of a specific type, executing a function for each neighbor. The function receives the target node, edge data, and source node. Returns the graph unchanged (for chaining).
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string; name: string };
+*
+* type Edges = {
+*     Project: { Task: { priority: number } };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Project", id: "1", name: "My Project" });
+* g = Graph.setNode(g, { type: "Task", id: "1", title: "First Task" });
+* g = Graph.setNode(g, { type: "Task", id: "2", title: "Second Task" });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], { priority: 1 });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"], { priority: 2 });
+*
+* Graph.forEachNeighbor(g, ["Project", "1"], "Task", (task, edge, project) => {
+*     console.log(`${project.name}: ${task.title} (priority: ${edge.priority})`);
+* });
+* // Logs:
+* // "My Project: First Task (priority: 1)"
+* // "My Project: Second Task (priority: 2)"
+* ```
+*
+*/
+function forEachNeighbor(graph, node, type, fn) {
+	const sourceNode = getNode(graph, node);
+	if (!sourceNode) return graph;
+	const nodeMap = graph.get("nodes")?.get(type);
+	if (!nodeMap) return graph;
+	for (const [targetId, edge] of graph.get("edges")?.get(sourceNode.type)?.get(sourceNode.id)?.get(type) ?? []) fn(nodeMap.get(targetId), edge, sourceNode);
+	return graph;
+}
+
+//#endregion
+export { forEachNeighbor };

package/dist/Graph/forEachNode.d.mts

@@ -0,0 +1,49 @@
+import { Edges, Graph, Node, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/forEachNode.d.ts
+/**
+ * # forEachNode
+ *
+ * ```ts
+ * function Graph.forEachNode(
+ *     graph: Graph,
+ *     type: NodeType,
+ *     fn: (node: Node) => void,
+ * ): Graph
+ * ```
+ *
+ * Iterates over all nodes of a specific type, executing a function for each node. Returns the graph unchanged (for chaining).
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Task", id: "1", title: "First Task" });
+ * g = Graph.setNode(g, { type: "Task", id: "2", title: "Second Task" });
+ * g = Graph.setNode(g, { type: "Task", id: "3", title: "Third Task" });
+ *
+ * Graph.forEachNode(g, "Task", (task) => {
+ *     console.log(task.title);
+ * });
+ * // Logs:
+ * // "First Task"
+ * // "Second Task"
+ * // "Third Task"
+ * ```
+ *
+ */
+declare function forEachNode<N extends Node, E extends Edges<N>, U extends NodeType<N>>(graph: Graph<N, E>, type: U, fn: (node: NoInfer<NodeOfType<N, U>>) => void): Graph<N, E>;
+//#endregion
+export { forEachNode };

package/dist/Graph/forEachNode.mjs

@@ -0,0 +1,51 @@
+//#region src/Graph/forEachNode.ts
+/**
+* # forEachNode
+*
+* ```ts
+* function Graph.forEachNode(
+*     graph: Graph,
+*     type: NodeType,
+*     fn: (node: Node) => void,
+* ): Graph
+* ```
+*
+* Iterates over all nodes of a specific type, executing a function for each node. Returns the graph unchanged (for chaining).
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Task", id: "1", title: "First Task" });
+* g = Graph.setNode(g, { type: "Task", id: "2", title: "Second Task" });
+* g = Graph.setNode(g, { type: "Task", id: "3", title: "Third Task" });
+*
+* Graph.forEachNode(g, "Task", (task) => {
+*     console.log(task.title);
+* });
+* // Logs:
+* // "First Task"
+* // "Second Task"
+* // "Third Task"
+* ```
+*
+*/
+function forEachNode(graph, type, fn) {
+	for (const node of graph.get("nodes")?.get(type)?.values() ?? []) fn(node);
+	return graph;
+}
+
+//#endregion
+export { forEachNode };

package/dist/Graph/fromJS.d.mts

@@ -0,0 +1,55 @@
+import { Edge, Edges, Graph, Node, NodeId } from "./types.mjs";
+
+//#region src/Graph/fromJS.d.ts
+/**
+ * # fromJS
+ *
+ * ```ts
+ * function Graph.fromJS(data: {
+ *     nodes: Node[];
+ *     edges: [NodeType, NodeId, NodeType, NodeId, EdgeData][];
+ * }): Graph
+ * ```
+ *
+ * Creates a graph from a plain JavaScript object representation. Useful for deserializing graphs from JSON or other storage formats.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const data = {
+ *     nodes: [
+ *         { type: "Project", id: "1" },
+ *         { type: "Task", id: "1", title: "My Task" },
+ *         { type: "Task", id: "2", title: "Another Task" },
+ *     ],
+ *     edges: [
+ *         ["Project", "1", "Task", "1", undefined],
+ *         ["Project", "1", "Task", "2", undefined],
+ *     ],
+ * };
+ *
+ * const graph = Graph.fromJS<Nodes, Edges>(data);
+ *
+ * Graph.hasNode(graph, ["Project", "1"]); // true
+ * Graph.hasEdge(graph, ["Project", "1"], ["Task", "1"]); // true
+ * ```
+ *
+ */
+declare function fromJS<N extends Node, E extends Edges<N>>(data: {
+  edges: [string, NodeId, string, NodeId, Edge][];
+  nodes: Node[];
+}): Graph<N, E>;
+//#endregion
+export { fromJS };

package/dist/Graph/fromJS.mjs

@@ -0,0 +1,62 @@
+import { batch } from "./batch.mjs";
+import { create } from "./create.mjs";
+import { setEdge } from "./setEdge.mjs";
+import { setNode } from "./setNode.mjs";
+
+//#region src/Graph/fromJS.ts
+/**
+* # fromJS
+*
+* ```ts
+* function Graph.fromJS(data: {
+*     nodes: Node[];
+*     edges: [NodeType, NodeId, NodeType, NodeId, EdgeData][];
+* }): Graph
+* ```
+*
+* Creates a graph from a plain JavaScript object representation. Useful for deserializing graphs from JSON or other storage formats.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const data = {
+*     nodes: [
+*         { type: "Project", id: "1" },
+*         { type: "Task", id: "1", title: "My Task" },
+*         { type: "Task", id: "2", title: "Another Task" },
+*     ],
+*     edges: [
+*         ["Project", "1", "Task", "1", undefined],
+*         ["Project", "1", "Task", "2", undefined],
+*     ],
+* };
+*
+* const graph = Graph.fromJS<Nodes, Edges>(data);
+*
+* Graph.hasNode(graph, ["Project", "1"]); // true
+* Graph.hasEdge(graph, ["Project", "1"], ["Task", "1"]); // true
+* ```
+*
+*/
+function fromJS(data) {
+	return batch(create(), (graph) => {
+		for (const node of data.nodes) graph = setNode(graph, node);
+		for (const [sourceType, sourceId, targetType, targetId, edge] of data.edges) graph = setEdge(graph, [sourceType, sourceId], [targetType, targetId], edge);
+		return graph;
+	});
+}
+
+//#endregion
+export { fromJS };

package/dist/Graph/getEdge.d.mts

@@ -0,0 +1,50 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/getEdge.d.ts
+/**
+ * # getEdge
+ *
+ * ```ts
+ * function Graph.getEdge(
+ *     graph: Graph,
+ *     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ * ): EdgeData | undefined
+ * ```
+ *
+ * Retrieves the edge data between two nodes. Returns `undefined` if the edge doesn't exist.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: { assignedAt: Date } };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Project", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "1" });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], {
+ *     assignedAt: new Date(),
+ * });
+ *
+ * const edge = Graph.getEdge(g, ["Project", "1"], ["Task", "1"]);
+ * // edge: { assignedAt: Date }
+ *
+ * const missing = Graph.getEdge(g, ["Project", "1"], ["Task", "2"]);
+ * // missing: undefined
+ * ```
+ *
+ */
+declare function getEdge<N extends Node, E extends Edges<N>, N1 extends keyof Bimap<E> & NodeType<N>, N2 extends keyof Bimap<E>[N1] & NodeType<N>>(graph: Graph<N, E>, source: NodeIdentifier<N, N1>, target: NodeIdentifier<N, N2>): Bimap<E>[N1][N2] | undefined;
+//#endregion
+export { getEdge };

package/dist/Graph/getEdge.mjs

@@ -0,0 +1,54 @@
+import { parseNodeIdentifier } from "./internals/parseNodeIdentifier.mjs";
+
+//#region src/Graph/getEdge.ts
+/**
+* # getEdge
+*
+* ```ts
+* function Graph.getEdge(
+*     graph: Graph,
+*     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+* ): EdgeData | undefined
+* ```
+*
+* Retrieves the edge data between two nodes. Returns `undefined` if the edge doesn't exist.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: { assignedAt: Date } };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Project", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "1" });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], {
+*     assignedAt: new Date(),
+* });
+*
+* const edge = Graph.getEdge(g, ["Project", "1"], ["Task", "1"]);
+* // edge: { assignedAt: Date }
+*
+* const missing = Graph.getEdge(g, ["Project", "1"], ["Task", "2"]);
+* // missing: undefined
+* ```
+*
+*/
+function getEdge(graph, source, target) {
+	const [sourceType, sourceId] = parseNodeIdentifier(source);
+	const [targetType, targetId] = parseNodeIdentifier(target);
+	return graph.get("edges")?.get(sourceType)?.get(sourceId)?.get(targetType)?.get(targetId);
+}
+
+//#endregion
+export { getEdge };

package/dist/Graph/getEdges.d.mts

@@ -0,0 +1,47 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/getEdges.d.ts
+/**
+ * # getEdges
+ *
+ * ```ts
+ * function Graph.getEdges(
+ *     graph: Graph,
+ *     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     type: NodeType,
+ * ): EdgeData[]
+ * ```
+ *
+ * Retrieves all edges of a specific type from a source node.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: { priority: number } };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Project", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "2" });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], { priority: 1 });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"], { priority: 2 });
+ *
+ * const edges = Graph.getEdges(g, ["Project", "1"], "Task");
+ * // edges: [{ priority: 1 }, { priority: 2 }]
+ * ```
+ *
+ */
+declare function getEdges<N extends Node, E extends Edges<N>, N1 extends keyof Bimap<E> & NodeType<N>, N2 extends keyof Bimap<E>[N1] & NodeType<N>>(graph: Graph<N, E>, source: NodeIdentifier<N, N1>, type: N2): Bimap<E>[N1][N2][];
+//#endregion
+export { getEdges };

package/dist/Graph/getEdges.mjs

@@ -0,0 +1,51 @@
+import { parseNodeIdentifier } from "./internals/parseNodeIdentifier.mjs";
+
+//#region src/Graph/getEdges.ts
+/**
+* # getEdges
+*
+* ```ts
+* function Graph.getEdges(
+*     graph: Graph,
+*     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     type: NodeType,
+* ): EdgeData[]
+* ```
+*
+* Retrieves all edges of a specific type from a source node.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: { priority: number } };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Project", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "2" });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"], { priority: 1 });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"], { priority: 2 });
+*
+* const edges = Graph.getEdges(g, ["Project", "1"], "Task");
+* // edges: [{ priority: 1 }, { priority: 2 }]
+* ```
+*
+*/
+function getEdges(graph, source, type) {
+	const [sourceType, sourceId] = parseNodeIdentifier(source);
+	const edgeMap = graph.get("edges")?.get(sourceType)?.get(sourceId)?.get(type);
+	return edgeMap ? [...edgeMap.values()] : [];
+}
+
+//#endregion
+export { getEdges };