@neo4j-nvl/base 2.0.0-c8e499dc → 2.0.0-ec6fdba7

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

@@ -1,8 +1,8 @@
-import type { ForceDirectedOptions, NvlState } from '../../modules/state/types';
-import type { Node, PartialNode, Relationship } from '../../types/graph-element';
-import { type ClusterHitRegion } from '../../utils/clusterHitRegions';
-import { type Point } from '../../utils/geometry';
-import type { CoarsenedGraph } from './clustering/types';
+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
@@ -17,259 +17,259 @@ export declare const ConvergenceCheckInterval = 20;
  */
 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;
-}
+  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

@@ -1,6 +1,6 @@
-import type { ClusterByFn, ClusterId } from '../../../modules/state/types';
-import type { Node, Relationship } from '../../../types/graph-element';
-import type { CoarsenedGraph } from './types';
+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}.
  */
@@ -11,52 +11,52 @@ export declare const DEFAULT_CROSS_CLUSTER_RELATIONSHIP_MULTIPLIER = 0;
  * 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;
-}
+  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;
+}