@neo4j-nvl/base 1.2.2 → 2.0.0-1e695738

package/dist/types/layouts/animatedlayout/AnimatedLayout.d.ts

@@ -1,25 +1,25 @@
-import type { NvlState } from '../../modules/state/types';
-import type { Node } from '../../types/graph-element';
+import { Node, PartialNode } from "../../types/graph-element.js";
+import { NvlState } from "../../modules/state/types.js";
 export default class AnimatedLayout {
-    positions: Record<string, Node>;
-    oldPositions: Record<string, Node>;
-    startTime: number;
-    t: number;
-    currentT: number;
+  positions: Record<string, Node>;
+  oldPositions: Record<string, Node>;
+  startTime: number;
+  t: number;
+  currentT: number;
+  state: NvlState;
+  shouldUpdateAnimator: boolean;
+  parents: Record<string, string>;
+  animationCompleteCallback: () => void;
+  shouldUpdate: boolean;
+  constructor(config: {
     state: NvlState;
-    shouldUpdateAnimator: boolean;
-    parents: Record<string, string>;
-    animationCompleteCallback: () => void;
-    shouldUpdate: boolean;
-    constructor(config: {
-        state: NvlState;
-        animationCompleteCallback?: () => void;
-    });
-    private getPositionMapFromState;
-    updatePositionsFromState(): void;
-    updateOldPositionFromState(): void;
-    startAnimation(): void;
-    update(): void;
-    updateNodes(positionList: Node[]): void;
-    getNodePositions(nodeList: Node[]): Node[];
-}
+    animationCompleteCallback?: () => void;
+  });
+  private getPositionMapFromState;
+  updatePositionsFromState(): void;
+  updateOldPositionFromState(): void;
+  startAnimation(): void;
+  update(): void;
+  updateNodes(positionList: PartialNode[]): void;
+  getNodePositions(nodeList: Node[]): Node[];
+}

package/dist/types/layouts/animatedlayout/animationUtils.d.ts

@@ -1,9 +1,9 @@
-import type { Node } from '../../types/graph-element';
-import type { Point } from '../../utils/geometry';
+import { Point } from "../../utils/geometry.js";
+import { Node } from "../../types/graph-element.js";
 /**
  * Calculates the average node coordinates for a given set of nodes.
  * @param nodes - The nodes to calculate the average position for.
  * @param positions - The positions of the nodes.
  * @returns The average node coordinates.
  */
-export declare const calculateAverageNodePosition: (nodes: Node[], positions: Record<string, Node | Point>) => number[];
+export declare const calculateAverageNodePosition: (nodes: Node[], positions: Record<string, Node | Point>) => number[];

package/dist/types/layouts/circularLayout/CircularLayout.d.ts

@@ -1,18 +1,18 @@
-import type { CircularOptions, LayoutOptions, NvlState } from '../../modules/state/types';
-import AnimatedLayout from '../animatedlayout/AnimatedLayout';
+import { CircularOptions, LayoutOptions, NvlState } from "../../modules/state/types.js";
+import AnimatedLayout from "../animatedlayout/AnimatedLayout.js";
 type CircularLayoutConfig = {
-    state: NvlState;
+  state: NvlState;
 } & CircularOptions;
 export declare class CircularLayout extends AnimatedLayout {
-    private stateDisposers;
-    private sortFunction;
-    constructor(config: CircularLayoutConfig);
-    setOptions(options?: LayoutOptions): void;
-    update(refreshPositions?: boolean): void;
-    getShouldUpdate(): boolean;
-    getComputing(): boolean;
-    private layout;
-    terminateUpdate(): void;
-    destroy(): void;
+  private stateDisposers;
+  private sortFunction;
+  constructor(config: CircularLayoutConfig);
+  setOptions(options?: LayoutOptions): void;
+  update(refreshPositions?: boolean): void;
+  getShouldUpdate(): boolean;
+  getComputing(): boolean;
+  private layout;
+  terminateUpdate(): void;
+  destroy(): void;
 }
-export {};
+export {};

package/dist/types/layouts/d3forcelayout/circularLayout.d.ts

@@ -1,5 +1,5 @@
-import type { D3Node } from './types';
+import { D3Node } from "./types.js";
 export declare function circularLayout(nodes: D3Node[], center: {
-    x: number;
-    y: number;
-}, radius: number): void;
+  x: number;
+  y: number;
+}, radius: number): void;

package/dist/types/layouts/d3forcelayout/constants.d.ts

@@ -1,5 +1,5 @@
-import type { SimulationLinkDatum, SimulationNodeDatum } from 'd3-force';
-import type { D3Node } from './types';
+import { D3Node } from "./types.js";
+import { SimulationLinkDatum, SimulationNodeDatum } from "d3-force";
 export declare const VELOCITY_DECAY = 0.4;
 export declare const DEFAULT_ALPHA = 1;
 export declare const DEFAULT_ALPHA_TARGET = 0;
@@ -12,8 +12,7 @@ export declare const BARNES_HUT_THETA = 1.2;
 export declare const FORCE_LINK_DISTANCE: (relationship: SimulationLinkDatum<D3Node>) => number;
 export declare const FORCE_LINK_STRENGTH: (link: SimulationLinkDatum<SimulationNodeDatum>, count: number[]) => number;
 export declare const FORCE_COLLIDE_RADIUS: (node: D3Node) => number;
-export declare const LAYOUT_RADIUS: (numberOfNodes: number) => number;
 export declare const FORCE_CHARGE: () => number;
 export declare const FORCE_CHARGE_START: () => number;
 export declare const FORCE_CENTER_X = 0.03;
-export declare const FORCE_CENTER_Y = 0.03;
+export declare const FORCE_CENTER_Y = 0.03;

package/dist/types/layouts/d3forcelayout/d3ForceLayout.d.ts

@@ -1,33 +1,33 @@
-import type { Simulation, SimulationLinkDatum, SimulationNodeDatum } from 'd3-force';
-import type { NvlState } from '../../modules/state/types';
-import type { Node, Relationship } from '../../types/graph-element';
-import type { Point } from '../../utils/geometry';
-import type { D3Node } from './types';
+import { Point } from "../../utils/geometry.js";
+import { Node, PartialNode, Relationship } from "../../types/graph-element.js";
+import { NvlState } from "../../modules/state/types.js";
+import { D3Node } from "./types.js";
+import { Simulation, SimulationLinkDatum, SimulationNodeDatum } from "d3-force";
 export declare class D3ForceLayout {
+  state: NvlState;
+  d3Nodes: Record<string, D3Node>;
+  d3RelList: SimulationLinkDatum<D3Node>[];
+  computing: boolean;
+  center: Point;
+  nodeRelCount: number[];
+  simulation: Simulation<SimulationNodeDatum, undefined>;
+  simulationStopped: boolean;
+  shouldUpdate: boolean;
+  shouldReheatNodes: boolean;
+  shouldCountNodeRels: boolean;
+  stateDisposers: (() => void)[];
+  constructor(config: {
     state: NvlState;
-    d3Nodes: Record<string, D3Node>;
-    d3RelList: SimulationLinkDatum<D3Node>[];
-    computing: boolean;
-    center: Point;
-    nodeRelCount: number[];
-    simulation: Simulation<SimulationNodeDatum, undefined>;
-    simulationStopped: boolean;
-    shouldUpdate: boolean;
-    shouldReheatNodes: boolean;
-    shouldCountNodeRels: boolean;
-    stateDisposers: (() => void)[];
-    constructor(config: {
-        state: NvlState;
-    });
-    setOptions(options: any): void;
-    updateNodes(positionList: D3Node[]): void;
-    update(refreshPositions?: boolean): void;
-    layout(_nodes: Node[], _rels: Relationship[], firstTimeAddingNodes: boolean): void;
-    getNodePositions(nodeList: D3Node[]): any[];
-    getShouldUpdate(): boolean;
-    getComputing(): boolean;
-    terminateUpdate(): void;
-    destroy(): void;
-    setAlpha(alpha: number): void;
-    countNodeRels(): any[];
-}
+  });
+  setOptions(options: any): void;
+  updateNodes(positionList: PartialNode[]): void;
+  update(refreshPositions?: boolean): void;
+  layout(_nodes: Node[], _rels: Relationship[], firstTimeAddingNodes: boolean): void;
+  getNodePositions(nodeList: D3Node[]): any[];
+  getShouldUpdate(): boolean;
+  getComputing(): boolean;
+  terminateUpdate(): void;
+  destroy(): void;
+  setAlpha(alpha: number): void;
+  countNodeRels(): any[];
+}

package/dist/types/layouts/d3forcelayout/types.d.ts

@@ -1,8 +1,8 @@
-import type { Node } from '../../types/graph-element';
+import { Node } from "../../types/graph-element.js";
 export type D3Node = Node & {
-    vx?: number;
-    vy?: number;
-    fx?: number;
-    fy?: number;
-    index?: number;
-};
+  vx?: number;
+  vy?: number;
+  fx?: number;
+  fy?: number;
+  index?: number;
+};

package/dist/types/layouts/forcedirectedlayout/PhysLayout.d.ts

@@ -0,0 +1,275 @@
+import { Point } from "../../utils/geometry.js";
+import { Node, PartialNode, Relationship } from "../../types/graph-element.js";
+import { ForceDirectedOptions, NvlState } from "../../modules/state/types.js";
+import { CoarsenedGraph } from "./clustering/types.js";
+import { ClusterHitRegion } from "../../utils/clusterHitRegions.js";
+/**
+ * Collision multipliers below this are floored to 0, which makes the shader skip its
+ * all-pairs collision loop. Every fine-level force in that loop is scaled by the same
+ * multiplier, so at this strength they move nothing worth the O(n^2) cost.
+ */
+export declare const CollisionMultiplierSkipThreshold = 0.05;
+export declare const ConvergenceCheckInterval = 20;
+/**
+ * Number of consecutive convergence checks that must report a below-threshold
+ * graph speed before the layout is considered settled. This debounces a single
+ * lucky-low reading so a still-moving graph isn't stopped prematurely.
+ */
+export declare const StableChecksToConverge = 3;
+export declare class PhysLayout {
+  private physVbo;
+  private physSmallVbo;
+  private physProjection;
+  private physSmallProjection;
+  private gl;
+  private averageNodeSize;
+  private shouldUpdate;
+  private iterationCount;
+  private nodeVariation;
+  private nodeCenterPoint;
+  private peakIterationMultiplier;
+  private stateDisposers;
+  private state;
+  private dpr;
+  private maxGlNodeSize;
+  private simulationStopVelocitySquared;
+  private gravity;
+  private force;
+  private nodeIdToIndex;
+  private nodeIndexToId;
+  private flatRelationshipKeys;
+  private numNodes;
+  private subGraphs;
+  private firstUpdate;
+  private curPhysData;
+  private apprxRepForceShader;
+  private levelsClusterTexture;
+  private levelsFinestIndexTexture;
+  private initalLevelTexture;
+  private levelsData;
+  private collisionDetectionMultiplier;
+  private physShader;
+  private physData;
+  private pinData;
+  private updateData;
+  private updateShader;
+  private physPositions;
+  private physDirty;
+  private positionsCacheVersion;
+  private convergencePbo;
+  private convergenceFence;
+  private convergenceSnapshot;
+  private readonly cpuWritesSinceAsyncReadback;
+  private hadSyncReadback;
+  private graphIsStableCount;
+  private springTexture;
+  private sizeTexture;
+  private offsetTexture;
+  private pinTexture;
+  private addedNodes;
+  private seedingMethod;
+  private clusterBy?;
+  private crossClusterRelationshipMultiplier;
+  private lastClusterByAssignments;
+  private lastClusterIdsBySun;
+  private sunMap;
+  private cachedClusterHitRegions;
+  private cachedClusterHitRegionsVersion;
+  private updateTexture;
+  private physVao;
+  private physSmallVao;
+  private updateVao;
+  constructor(config: ForceDirectedOptions & {
+    webGLContext: WebGL2RenderingContext;
+    state: NvlState;
+  });
+  /**
+   * Sets the layout options.
+   * @param options - The object with the options.
+   * @param initial - Whether this is the first setting of options.
+   */
+  setOptions(options?: ForceDirectedOptions, initial?: boolean): void;
+  private applyClusteringOptions;
+  private applyCrossClusterMultiplier;
+  private applyClusterBy;
+  private wakeLayout;
+  private coarsenGraph;
+  /**
+   * Sets graph data to be used
+   * @param {{ nodes: Node[]; rels: Relationship[] }} data the graph object
+   * @returns The top level graph of the subgraphs created by the solar merger.
+   */
+  setData(data: {
+    nodes: Node[];
+    rels: Relationship[];
+  }): CoarsenedGraph;
+  /**
+   * Updates the node's positions for the next step in the physics layout iterations if the layout needs to update
+   * @param refreshPositions whether the entire layout should be reheated
+   * @returns Whether the layout should update in the following step.
+   */
+  update(refreshPositions?: boolean): boolean;
+  /**
+   * Stops the layout
+   */
+  terminateUpdate(): void;
+  /**
+   * Synchronously reads the latest node positions/velocities from the GPU into
+   * this.physPositions.
+   */
+  private readbackPositions;
+  /**
+   * Drives the convergence-readback state machine for the current iteration:
+   * consumes a pending fence if one is ready, otherwise starts a new readback
+   * when a convergence check is due.
+   * @returns Whether fresh velocity data is available.
+   */
+  private tryConsumeConvergenceReadback;
+  /**
+   * The GPU texture holding the latest node positions (xy) and velocities (zw).
+   * @returns The RGBA32F position texture.
+   *
+   * @note Texel layout matches the WebGL renderer's `u_positions` sampler, so it
+   * can be bound directly to webgl renderer.
+   */
+  getPositionTexture(): WebGLTexture;
+  /**
+   * Maps node id to its texel index in the position texture.
+   * @returns The node-id-to-texel-index map.
+   *
+   * @note This is the coarsening / solar-hierarchy order (re-derived on add/remove), which
+   * differs from the renderer's insertion order. Consumers rendering from {@link getPositionTexture}
+   * must build their sampling indices from this.
+   */
+  getNodeTexelIndices(): Readonly<Record<Node['id'], number>>;
+  /**
+   * Multilevel coarsening hierarchy produced by {@link SolarMerger} / {@link ClusterByMerger}.
+   * @returns The coarsened graph hierarchy.
+   * @see {@link CoarsenedGraph}
+   */
+  getSubGraphs(): CoarsenedGraph[];
+  /**
+   * Fitted convex-hull hit regions for multi-member {@link ClusteringOptions.clusterBy} clusters.
+   * Results are cached against {@link getPositionsCacheVersion}.
+   * @returns Cluster hit regions, or an empty array when clustering is inactive.
+   */
+  getClusterByHitRegions(): ClusterHitRegion[];
+  private shouldCheckConvergence;
+  /** Allocates the pixel-pack buffer used for the async convergence readback. */
+  private setupConvergencePbo;
+  /**
+   * Kicks off an async copy of the position texture into the pixel-pack buffer
+   * and fences it. Only issued when no readback is already in flight.
+   */
+  private issueConvergenceReadback;
+  /**
+   * Polls the in-flight fence without blocking; if the readback is ready,
+   * copies it into physPositions and clears the fence.
+   * @returns Whether fresh velocity data was consumed this call.
+   */
+  private consumeConvergenceReadback;
+  private restoreCpuWrittenPositions;
+  /** Drops any in-flight readback fence (on stop, reset, or destroy). */
+  private cancelConvergenceReadback;
+  /**
+   * Returns whether the current layout needs to be updated in the next iteration step.
+   * @returns Whether the layout should update in the following step.
+   */
+  getShouldUpdate(): boolean;
+  /**
+   * Returns whether the current layout is computing.
+   * Always returns false because the force-directed layout has no computing step.
+   * @returns Whether the layout is computing.
+   */
+  getComputing(): boolean;
+  /**
+   * Version of the CPU position cache. Advances on GPU readback, CPU-mirror
+   * writes, and physics buffer reset.
+   * @returns The current cache version.
+   */
+  getPositionsCacheVersion(): number;
+  /**
+   * Adds the current x,y coordinates for each node to a given list of nodes.
+   * Forces a synchronous GPU readback when the cache is dirty.
+   * @param nodeList - The list of nodes to get positions for.
+   * @returns The list of nodes containing the x,y coordinates on each node object.
+   */
+  getNodePositions(nodeList: Node[]): (Node & Point)[];
+  /**
+   * Maps {@link physPositions} onto a node list without forcing a GPU readback.
+   * Positions may lag behind the live GPU texture until the next sync/async refresh.
+   * @param nodeList - The list of nodes to get positions for.
+   * @returns The list of nodes containing the cached x,y coordinates.
+   */
+  getCachedNodePositions(nodeList: Node[]): (Node & Point)[];
+  /**
+   * Reheats the layout
+   * @param fullData - The entire graph object.
+   */
+  reheat(fullData: {
+    nodes: Node[];
+    rels?: Relationship[];
+  }): void;
+  /**
+   * Updates the existing nodes of a graph with a given list of updates
+   * @param nodeList - The list of updates.
+   */
+  updateNodes(nodeList: PartialNode[]): void;
+  /**
+   * Writes a node position into the current phys position texture and CPU mirror.
+   * Caller must bind {@link getPositionTexture} first.
+   */
+  private writePhysPosition;
+  /**
+   * Adds and removes nodes from the graph based on given updates
+   * @param fullData - The entire graph object.
+   * @param fullData.nodes - The nodes in the graph.
+   * @param fullData.rels - The relationships in the graph.
+   * @param nodeChanges - The changes in the graph.
+   * @param nodeChanges.adds - A list of nodes to be added.
+   * @param nodeChanges.removes - A list of nodes to be removed.
+   */
+  addRemoveData(fullData: {
+    nodes: Node[];
+    rels: Relationship[];
+  }, nodeChanges: {
+    adds: Record<string, Node>;
+    removes: Record<string, Node>;
+  }, relationshipChanges: {
+    adds: Record<string, Relationship>;
+    removes: Record<string, Relationship>;
+  }): CoarsenedGraph;
+  /**
+   * Destroys the class and all buffers and textures.
+   */
+  destroy(): void;
+  /**
+   * Takes the new flat key set of relationships and the current relationship changes
+   * and checks whether removed relationships are still in the new flat key set.
+   * and whether added relationships were already in the old flat key set.
+   * @param newFlatKeySet The new flat key set of relationships.
+   * @param relationshipChanges The changes in the relationships.
+   * @returns Whether the relationship flat map has changed.
+   */
+  private hasRelationshipFlatMapChanged;
+  private dumpTexture;
+  private getScaleNumber;
+  private getBaseLength;
+  private checkForUpdates;
+  private getNodePosition;
+  private getMaxSpeedSquared;
+  private getPhysData;
+  private newTexture;
+  private newFramebuffer;
+  private checkCompatibility;
+  private printGlStats;
+  private adjustToGlSize;
+  private setupSize;
+  private setupSprings;
+  private setupPhysics;
+  private setupPhysicsForNodes;
+  private setupPhysicsForCoarse;
+  private setupPinData;
+  private setupUpdates;
+  private definePhysicsArrays;
+}

package/dist/types/layouts/forcedirectedlayout/clustering/ClusterByMerger.d.ts

@@ -0,0 +1,62 @@
+import { Node, Relationship } from "../../../types/graph-element.js";
+import { ClusterByFn, ClusterId } from "../../../modules/state/types.js";
+import { CoarsenedGraph } from "./types.js";
+/**
+ * Default value for {@link ForceDirectedOptions.crossClusterRelationshipMultiplier}.
+ */
+export declare const DEFAULT_CROSS_CLUSTER_RELATIONSHIP_MULTIPLIER = 0;
+/**
+ * Builds a two-level Sun/Planet hierarchy from semantic cluster identifiers.
+ * Nodes sharing the same cluster id become planets orbiting a new synthetic cluster sun.
+ * Nodes without a cluster id remain independent suns.
+ */
+export default class ClusterByMerger {
+  subGraphs: CoarsenedGraph[];
+  sunMap: Record<string, string>;
+  memberMap: Record<string, string[]>;
+  relIdMap: string[][];
+  clusterAssignments: Map<string, ClusterId | undefined>;
+  clusterIdsBySun: Map<string, ClusterId>;
+  private nodeSortMap;
+  /**
+   * Coarsens the input graph into a property-based solar hierarchy.
+   * @param inputGraph - The nodes and relationships to coarsen.
+   * @param nodeIdToIndex - Maps node ids to contiguous array indices.
+   * @param clusterBy - Returns a cluster id for each node, or undefined for independent nodes.
+   */
+  constructor(inputGraph: {
+    nodes: Node[];
+    rels: Relationship[];
+  }, nodeIdToIndex: Record<string, number>, clusterBy: ClusterByFn);
+  /**
+   * Clones the finest adjacency and adds an undirected "star" edge from each cluster member to its
+   * Sun, skipping any pair already connected by a real edge.
+   * Layout-only: fed to the spring solver, never written back into the real
+   * adjacency and never rendered.
+   * @param suns - The cluster suns, each with its planets, post-sort.
+   * @param finestRelationships - The finest-level real adjacency (sorted index space).
+   * @returns A cloned adjacency augmented with intra-cluster star edges.
+   */
+  private buildClusterSpringRelationships;
+  /**
+   * Groups node indices into buckets by cluster id, preserving first-seen order.
+   * Nodes without a cluster id each get their own single-node bucket.
+   * @param nodes - Input graph nodes indexed by position.
+   * @param clusterBy - Returns a cluster id for each node, or undefined for independent nodes.
+   * @returns Arrays of node indices, one bucket per cluster or independent node.
+   */
+  private groupNodesByCluster;
+  /**
+   * Converts cluster buckets into a Sun/Planet hierarchy for the first coarsening level.
+   * Each bucket with more than one node gets a synthetic Sun and the members become its planets.
+   * Single-member buckets keep the real node as Sun.
+   * @param buckets - Node index groups produced by {@link groupNodesByCluster}.
+   * @param nodes - Input graph nodes indexed by position.
+   * @param solarNodes - Solar nodes to extend with synth suns.
+   * @param relationships - Adjacency lists to extend with rows for synth suns.
+   * @param relIdMap - Relationship id lists to extend with rows for synth suns.
+   * @returns Cluster suns, index maps for node-sun and relationship ids and
+   * copies of solar nodes / adjacency / rel id lists with synth suns appended.
+   */
+  private buildPropertyHierarchy;
+}

package/dist/types/layouts/forcedirectedlayout/clustering/SolarMerger.d.ts

@@ -0,0 +1,56 @@
+import { Node, Relationship } from "../../../types/graph-element.js";
+import { CoarsenedGraph, SolarRelationship } from "./types.js";
+/**
+ * Coarsens a graph into a hierarchy of "solar systems", following the sun/planet/moon partitioning scheme from
+ * Hachul and Jünger, "Drawing Large Graphs with a Potential-Field-Based Multilevel Algorithm".
+ *
+ * @see {@link https://kups.ub.uni-koeln.de/1409/ Drawing Large Graphs with a Potential-Field-Based Multilevel Algorithm}
+ */
+export default class SolarMerger {
+  graph: {
+    nodes: Node[];
+    relationships: number[][];
+    idToRel: Record<string, SolarRelationship>;
+  };
+  subGraphs: CoarsenedGraph[];
+  sunMap: Record<string, string>;
+  memberMap: Record<string, string[]>;
+  relIdMap: string[][];
+  nodeSortMap?: Record<number, number>;
+  constructor(inputGraph: {
+    nodes: Node[];
+    rels: Relationship[];
+  }, nodeIdToIndex: Record<string, number>);
+  /**
+   * Repeatedly coarsens the graph, one solar-system level at a time, until it has at most `targetSize` nodes or
+   * cannot be coarsened further. Each level's result is recorded in {@link SolarMerger.subGraphs}.
+   *
+   * @param targetSize - The node count to coarsen down to.
+   * @returns The coarsest graph reached.
+   */
+  coarsenTo(targetSize: number): CoarsenedGraph;
+  /**
+   * Repeatedly coarsens the graph by exactly `levelToCoarsenBy` solar-system levels, regardless of the resulting
+   * node count. Each level's result is recorded in {@link SolarMerger.subGraphs}.
+   *
+   * @param levelToCoarsenBy - The number of levels to coarsen by.
+   * @returns The coarsest graph reached.
+   */
+  coarsenBy(levelToCoarsenBy: number): CoarsenedGraph;
+  /**
+   * Partitions `graph` into one level of solar systems and collapses each into a single node, producing the next
+   * coarser graph.
+   *
+   * Follows the three-step solar-system construction from Hachul and Jünger, "Drawing Large Graphs with a
+   * Potential-Field-Based Multilevel Algorithm" (create suns, label their neighbors as planets, assign
+   * remaining nodes as moons of their nearest planet).
+   *
+   * @param graph - The graph to coarsen by one level.
+   * @param firstIteration - Whether `graph` is the original, uncoarsened input graph.
+   * @returns The collapsed graph (`output`), the input graph with nodes reordered by solar system (`sortedInput`),
+   * and a map from the input graph's node ids to their position in `sortedInput` (`nodeSortMap`).
+   * @see {@link https://kups.ub.uni-koeln.de/1409/ Drawing Large Graphs with a Potential-Field-Based Multilevel Algorithm}
+   *
+   */
+  private coarsen;
+}