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

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

@@ -1,5 +1,5 @@
-import type { Node, Relationship } from '../../../types/graph-element';
-import type { CoarsenedGraph, SolarRelationship } from './types';
+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".
@@ -7,50 +7,50 @@ import type { CoarsenedGraph, SolarRelationship } from './types';
  * @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;
-}
+  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;
+}

package/dist/types/layouts/forcedirectedlayout/clustering/clustering-utils.d.ts

@@ -1,5 +1,5 @@
-import type { Node, Relationship } from '../../../types/graph-element';
-import type { CoarsenedGraph, PartialPlanet, PartialSun, SolarNode, SolarRelationship, Sun } from './types';
+import { Node, Relationship } from "../../../types/graph-element.js";
+import { CoarsenedGraph, PartialPlanet, PartialSun, SolarNode, SolarRelationship, Sun } from "./types.js";
 /**
  * Gets the original node ids belonging to a sun and its planets and moons.
  * @param sun - The sun to get the original node ids for.
@@ -41,13 +41,13 @@ export declare const isHub: (index: number, relationships: number[][], hubDegree
  * @returns Parsed adjacency data for coarsening.
  */
 export declare const buildAdjacencyGraph: (inputGraph: {
-    nodes: Node[];
-    rels: Relationship[];
+  nodes: Node[];
+  rels: Relationship[];
 }, nodeIdToIndex: Record<string, number>) => {
-    nodes: Node[];
-    relationships: number[][];
-    relIdMap: string[][];
-    idToRel: Record<string, SolarRelationship>;
+  nodes: Node[];
+  relationships: number[][];
+  relIdMap: string[][];
+  idToRel: Record<string, SolarRelationship>;
 };
 /**
  * Wraps input nodes as {@link SolarNode}s indexed by their original position.
@@ -59,12 +59,12 @@ export declare const createSolarNodesFromInput: (nodes: Node[]) => SolarNode[];
  * Creates a Planet with an unsettled parent link (caller must attach via {@link attachPlanetsToSun}).
  */
 export declare const createPlanet: (params: {
-    id: number;
-    sunId: number;
-    weight: number;
-    originalId: string;
-    finestIndex?: number;
-    size?: () => number;
+  id: number;
+  sunId: number;
+  weight: number;
+  originalId: string;
+  finestIndex?: number;
+  size?: () => number;
 }) => PartialPlanet;
 /**
  * Finalises a sun's planets list, weight/size/children closures, and back-links parent on each planet.
@@ -87,10 +87,10 @@ export declare const attachPlanetsToSun: (partialSun: PartialSun, planets: Parti
  * @returns A sun under construction, ready for {@link attachPlanetsToSun} (separate from the finest SolarNode).
  */
 export declare const createSynthClusterSun: (params: {
-    clusterId: string | number;
-    solarNodesWithSynths: SolarNode[];
-    relationshipsWithSynths: number[][];
-    relIdMapWithSynths: string[][];
+  clusterId: string | number;
+  solarNodesWithSynths: SolarNode[];
+  relationshipsWithSynths: number[][];
+  relIdMapWithSynths: string[][];
 }) => PartialSun;
 /**
  * Rolls node-level adjacency up to sun-level adjacency between clusters.
@@ -111,22 +111,22 @@ export declare const rollupInterSunRelationships: (relationships: number[][], no
  * @returns {{ relationships: number[][]; relIdMap: string[][] }} Remapped adjacency data.
  */
 export declare const remapAdjacencyWithSortMap: (relationships: number[][], nodeSortMap: Record<number, number>, relIdMap: string[][], remapRelIds?: boolean) => {
-    relationships: number[][];
-    relIdMap: string[][];
+  relationships: number[][];
+  relIdMap: string[][];
 };
 /** Input nodes that may receive a layout `finestIndex` during sorting (plain Node on first pass). */
 type SourceNode = (Node | SolarNode) & {
-    finestIndex?: number;
+  finestIndex?: number;
 };
 export type SortHierarchyOptions = {
-    suns: Sun[];
-    solarNodes: SolarNode[];
-    sourceNodes?: SourceNode[];
-    relationships: number[][];
-    relIdMap: string[][];
-    idToRel: Record<string, SolarRelationship>;
-    firstIteration?: boolean;
-    includeMoons?: boolean;
+  suns: Sun[];
+  solarNodes: SolarNode[];
+  sourceNodes?: SourceNode[];
+  relationships: number[][];
+  relIdMap: string[][];
+  idToRel: Record<string, SolarRelationship>;
+  firstIteration?: boolean;
+  includeMoons?: boolean;
 };
 /**
  * Sorts suns, planets, and optionally moons into shader layout order and builds the finest subgraph.
@@ -134,10 +134,10 @@ export type SortHierarchyOptions = {
  * @returns The finest subgraph, sort map, member-sun maps, and remapped relationship ids.
  */
 export declare const sortHierarchyForShaderLayout: ({ suns, solarNodes, sourceNodes, relationships, relIdMap, idToRel, firstIteration, includeMoons }: SortHierarchyOptions) => {
-    sortedInput: CoarsenedGraph;
-    nodeSortMap: Record<number, number>;
-    sunMap: Record<string, string>;
-    memberMap: Record<string, string[]>;
-    relIdMap: string[][];
+  sortedInput: CoarsenedGraph;
+  nodeSortMap: Record<number, number>;
+  sunMap: Record<string, string>;
+  memberMap: Record<string, string[]>;
+  relIdMap: string[][];
 };
-export {};
+export {};

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

@@ -1,59 +1,59 @@
-import type { Node } from '../../../types/graph-element';
+import { Node } from "../../../types/graph-element.js";
 export interface SolarNode extends Omit<Node, 'id' | 'size'> {
-    id: number;
-    weight?: number;
-    finestIndex?: number;
-    originalId: string;
-    position?: {
-        x: number;
-        y: number;
-    };
-    placement?: {
-        x: number;
-        y: number;
-    };
-    size?: number | (() => number);
-    synthetic?: boolean;
+  id: number;
+  weight?: number;
+  finestIndex?: number;
+  originalId: string;
+  position?: {
+    x: number;
+    y: number;
+  };
+  placement?: {
+    x: number;
+    y: number;
+  };
+  size?: number | (() => number);
+  synthetic?: boolean;
 }
 export interface SolarRelationship {
-    id: string;
-    from: string;
-    to: string;
+  id: string;
+  from: string;
+  to: string;
 }
 export interface CoarsenedGraph {
-    nodes: SolarNode[];
-    relationships: number[][];
-    idToRel: Record<string, SolarRelationship>;
-    /**
-     * Contains the "real" {@link relationships} plus any synthetic edges purely for layout purposes.
-     * Undefined when there are no synthetic edges (e.g. SolarMerger).
-     */
-    springRelationships?: number[][];
+  nodes: SolarNode[];
+  relationships: number[][];
+  idToRel: Record<string, SolarRelationship>;
+  /**
+   * Contains the "real" {@link relationships} plus any synthetic edges purely for layout purposes.
+   * Undefined when there are no synthetic edges (e.g. SolarMerger).
+   */
+  springRelationships?: number[][];
 }
 export interface Sun extends SolarNode {
-    planets: Planet[];
-    size: () => number;
-    children: () => Planet[];
-    previousIndex: number;
+  planets: Planet[];
+  size: () => number;
+  children: () => Planet[];
+  previousIndex: number;
 }
 /** Sun fields known before {@link attachPlanetsToSun} fills planets/size/children/weight. */
 export type PartialSun = Omit<Sun, 'planets' | 'size' | 'children' | 'previousIndex' | 'weight'>;
 export interface Planet extends SolarNode {
-    parent: Sun;
-    sunId: number;
-    moons: Moon[];
-    size: () => number;
-    children: () => Moon[];
+  parent: Sun;
+  sunId: number;
+  moons: Moon[];
+  size: () => number;
+  children: () => Moon[];
 }
 /** Planet fields known before {@link attachPlanetsToSun} sets parent. */
 export type PartialPlanet = Omit<Planet, 'parent'>;
 export interface Moon extends SolarNode {
-    parent: Planet;
-    sunId: number;
-    size: () => number;
+  parent: Planet;
+  sunId: number;
+  size: () => number;
 }
 export type Celestial = Sun | Planet | Moon;
 export declare const isSolarNode: (node: SolarNode | Node) => node is SolarNode;
 export declare const isSun: (node: SolarNode | Celestial) => node is Sun;
 export declare const isPlanet: (node: SolarNode | Celestial) => node is Planet;
-export declare const isMoon: (node: SolarNode | Celestial) => node is Moon;
+export declare const isMoon: (node: SolarNode | Celestial) => node is Moon;

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

@@ -1,4 +1,4 @@
 export default class GlWrapper {
-    constructor(gl: RenderingContext);
-    private wrapFunction;
-}
+  constructor(gl: RenderingContext);
+  private wrapFunction;
+}

package/dist/types/layouts/forcedirectedlayout/shaders/multilevel-fragment.d.ts

@@ -1,2 +1,2 @@
 declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_physData;\nuniform sampler2D u_connections;\nuniform sampler2D u_connectionOffsets;\nuniform sampler2D u_pinnedNodes;\nuniform sampler2D u_sizeTexture;\nuniform float u_baseLength;\nuniform float u_curIteration;\nuniform float u_iterationMultiplier;\nuniform vec2 u_gravityCenter;\nuniform float u_numNodes;\nuniform float u_gravity;\n\nuniform sampler2D u_clusterData;\nuniform sampler2D u_prevForce;\nuniform float u_collisionMultiplier;\nuniform float u_maxNodeSize;\nuniform float u_crossClusterRelationshipMultiplier;\n\nout vec4 fragColor;\n\nfloat DAMP = 0.6;\nfloat COOL = 0.99998;\nfloat TIMESTEP = 1.0 / 30.0;\nfloat VELOCITYDECAY = 0.6;\nfloat accLimitLow = 500000.0;\nfloat accLimitHigh = 750000.0;\nfloat accLimitPosHigh = 10000000.0;\n\nconst float denseNodeThreshold = 1000.0;\nconst float MIN_DISTANCE = 0.00000001;\nconst float MAX_DISTANCE = 1000000000.0;\nconst float MAX_ACCELERATION = 50000.0;\n\nvec4 getTextureData(sampler2D tex, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture(tex, vec2(x + 0.5, y + 0.5) / base);\n}\n\nbool isNan(float val) {\n  return (val < 0.0 || 0.0 < val || val == 0.0) ? false : true;\n}\n\nconst float BIG_NUMBER = 999999999999999999.0;\nbool isInf(float val) {\n  return val > BIG_NUMBER || val < -BIG_NUMBER;\n}\n\nvec2 getDelta(vec2 v1, vec2 v2) {\n  vec2 delta = v1 - v2;\n  float dist = length(delta);\n  if (dist < MIN_DISTANCE || isNan(dist)) {\n    return vec2(MIN_DISTANCE, MIN_DISTANCE);\n  }\n  if (dist > MAX_DISTANCE) {\n    vec2 normDelta = delta / dist;\n    return normDelta * MAX_DISTANCE;\n  }\n  return delta;\n}\n\nvec4 getOtherNodePosition(float i) {\n  return getTextureData(u_physData, i, 256.0);\n}\n\nfloat getCombinedNodeSize(float i, float nodeSize) {\n  float otherNodeSize = getTextureData(u_sizeTexture, i, 256.0).r;\n  return nodeSize + otherNodeSize;\n}\n\nvec2 getSpringForce(float curConnection, float numConnections, float springFScale, vec4 myPosition, float i, float myClusterStartIndex) {\n  float curSpring = getTextureData(u_connections, curConnection + i, 4096.0).r;\n\n  vec4 otherPosition = getTextureData(u_physData, curSpring, 256.0);\n  float otherDataPosition = getTextureData(u_connectionOffsets, curSpring, 256.0).r;\n  float otherNumConnections = getTextureData(u_connections, otherDataPosition, 4096.0).r;\n  float avgDegree = max((otherNumConnections + numConnections * 3.0) / 4.0, 4.0);\n\n  vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n  float dist = length(delta);\n\n  float F = (dist * dist * springFScale) / (u_baseLength * avgDegree) * u_collisionMultiplier;\n\n  // u_crossClusterRelationshipMultiplier only damps edges that cross a cluster boundary\n  if (u_crossClusterRelationshipMultiplier < 1.0) {\n    float otherClusterStartIndex = getTextureData(u_clusterData, curSpring, 256.0).y;\n    F *= otherClusterStartIndex == myClusterStartIndex ? 1.0 : u_crossClusterRelationshipMultiplier;\n  }\n\n  return (-delta / dist) * F;\n}\n\nvec2 getCollisionForce(float combinedNodeSize, float dist, float fScale, vec2 delta) {\n  float collisionForce = (combinedNodeSize - dist) / (dist) * u_collisionMultiplier;\n  return (delta * collisionForce * fScale * combinedNodeSize) / (combinedNodeSize + 1.0);\n}\n\nvec2 getRepulsionForce(float dist, float fScale, vec2 delta) {\n  float F = (u_baseLength * u_baseLength * fScale) / (dist) * u_collisionMultiplier;\n  return (delta / dist) * F * 0.05;\n}\n\nvoid main(void) {\n  float textureSide = 256.0; //#TEXTURE_SIDE#;\n  float index = (gl_FragCoord.x - 0.5) + (gl_FragCoord.y - 0.5) * textureSide;\n\n  if (index >= u_numNodes) {\n    discard;\n  }\n\n  vec4 clusterData = getTextureData(u_clusterData, index, 256.0);\n\n  float clusterIndex = clusterData.x;\n  float clusterStartIndex = clusterData.y;\n  float clusterSize = clusterData.z;\n\n  vec4 myPosition = getTextureData(u_physData, index, 256.0);\n  vec4 previousForce = getTextureData(u_prevForce, clusterIndex, 256.0);\n\n  vec2 acceleration = previousForce.xy;\n\n  float isPinned = getTextureData(u_pinnedNodes, index, 256.0).r;\n  float nodeSize = getTextureData(u_sizeTexture, index, 256.0).r;\n\n  if (isPinned > 0.5) {\n    fragColor = vec4(myPosition.xy, 0.0, 0.0);\n    return;\n  }\n\n  // Prime the second ping-pong texture with the initial state without calculating forces\n  // that would otherwise be discarded at the end of this first iteration.\n  if (u_curIteration == 0.0) {\n    fragColor = vec4(myPosition.xy, myPosition.zw);\n    return;\n  }\n\n  float curConnection = getTextureData(u_connectionOffsets, index, 256.0).r;\n  float numConnections = getTextureData(u_connections, curConnection, 4096.0).r;\n\n  float fScale = 1.0 + sqrt(u_iterationMultiplier);\n  float springFScale = fScale;\n\n  if (numConnections > denseNodeThreshold) {\n    springFScale = sqrt(fScale);\n  }\n\n  float numOfRels = 0.0;\n\n  // Springs\n  for (float i = 1.0; i <= 256.0 * 256.0; i++) {\n    if (numOfRels >= numConnections) {\n      break;\n    }\n    acceleration += getSpringForce(curConnection, numConnections, springFScale, myPosition, i, clusterStartIndex);\n    numOfRels += 1.0;\n  }\n\n  // Repulsion && collision detection.\n  if (u_collisionMultiplier > 0.0) {\n    float number_of_collisions = 0.0;\n    for (float i = 0.0; i < 256.0 * 256.0; i++) {\n      if (i >= u_numNodes) {\n        break;\n      }\n\n      if (i == index) {\n        continue;\n      }\n\n      vec4 otherPosition = getOtherNodePosition(i);\n      vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n      float dist = length(delta);\n\n      if (number_of_collisions < 40.0 && dist < (nodeSize + u_maxNodeSize) * 2.0) {\n        float combinedNodeSize = getCombinedNodeSize(i, nodeSize) * 2.0;\n        if (dist < combinedNodeSize) {\n          number_of_collisions++;\n          acceleration += getCollisionForce(combinedNodeSize, dist, fScale, delta);\n        }\n      }\n\n      if (i >= clusterStartIndex && i < clusterStartIndex + clusterSize) {\n        acceleration += getRepulsionForce(dist, fScale, delta);\n      }\n    }\n  }\n\n  // Gravity\n  vec2 delta = getDelta(u_gravityCenter, myPosition.xy);\n  float dist = length(delta);\n\n  vec2 grav = (delta / dist) * u_gravity * fScale * (dist / 1000.0);\n  acceleration += grav;\n\n  float accMagnitude = length(acceleration);\n  acceleration *= min(MAX_ACCELERATION, accMagnitude) / accMagnitude;\n\n  float iterationFrictionThreshold = 1000.0;\n\n  if (u_curIteration > iterationFrictionThreshold) {\n    float friction = 1.0 + pow((u_curIteration - iterationFrictionThreshold), 2.0) / 100.0;\n    acceleration *= 1.0 / friction;\n  }\n\n  float TEMP = max(0.02, pow(COOL, u_curIteration));\n  vec2 prevVelocity = myPosition.zw;\n  vec2 currentPos = myPosition.xy;\n\n  vec2 newPos = currentPos + TEMP * ( DAMP * (prevVelocity) + acceleration * TIMESTEP * TIMESTEP);\n  vec2 newVelocity = newPos - currentPos;\n  fragColor = vec4(newPos, newVelocity);\n}";
-export default _default;
+export { _default as default };

package/dist/types/layouts/forcedirectedlayout/shaders/multilevel-repulsive-fragment.d.ts

@@ -1,2 +1,2 @@
 declare const _default: "#version 300 es\nprecision mediump float;\nuniform sampler2D u_physData;\nuniform sampler2D u_clusterData;\nuniform sampler2D u_finestIndexes;\nuniform sampler2D u_prevForce;\n\nuniform float u_baseLength;\nuniform float u_numNodes;\nuniform float u_iterationMultiplier;\nuniform float u_isTopLevel;\n\nout vec4 fragColor;\n\nfloat PI = 3.1415926535897932384626433832795;\nfloat TIMESTEP = 1.0 / 30.0;\nfloat VELOCITYDECAY = 1.0;\n\nvec4 getTextureData(sampler2D tex, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture(tex, vec2(x + 0.5, y + 0.5) / base);\n}\n\nfloat getAdjustedClusterWeight(float clusterWeight) {\n  return (clusterWeight * clusterWeight) / (clusterWeight + 1.0);\n}\n\n// Repulsion area from peer mass (weight). .z size is only for mid-level loop bounds.\nfloat getPeerFootprintArea(float peerWeight) {\n  return pow(sqrt(peerWeight) * 4.0 + u_baseLength * 2.0, 2.0);\n}\n\nvoid main(void) {\n  float index = (gl_FragCoord.x - 0.5) + (gl_FragCoord.y - 0.5) * 256.0;\n\n  if (index >= u_numNodes) {\n    discard;\n  }\n\n  vec4 clusterData = getTextureData(u_clusterData, index, 256.0);\n  bool isTopLevel = u_isTopLevel == 1.0;\n\n  float clusterIndex = clusterData.x;\n  float clusterStartIndex = clusterData.y;\n  float clusterSize = clusterData.z;\n  float singleNodeRepulsionScale = isTopLevel && clusterSize == 1.0 ? 0.5 : 1.0;\n\n  float finestIndex = getTextureData(u_finestIndexes, index, 256.0).r;\n  vec4 myPosition = getTextureData(u_physData, finestIndex, 256.0);\n  vec4 previousForce = getTextureData(u_prevForce, clusterIndex, 256.0);\n  float fScale = 1.0 + sqrt(u_iterationMultiplier);\n\n  vec2 acceleration = previousForce.xy;\n\n  float loopEnd = isTopLevel ? u_numNodes : (clusterStartIndex + clusterSize);\n\n  // Repulsion & Collision Detection\n  for (float i = 0.0; i < 256.0 * 256.0; i++) {\n    if (i >= loopEnd || i >= u_numNodes) {\n      break;\n    }\n    if ((!isTopLevel && i < clusterStartIndex) || i == index) {\n      continue;\n    }\n\n    vec4 otherClusterData = getTextureData(u_clusterData, i, 256.0);\n    float otherClusterWeight = getAdjustedClusterWeight(otherClusterData.w);\n\n    float otherFinestIndex = getTextureData(u_finestIndexes, i, 256.0).r;\n    vec4 otherPosition = getTextureData(u_physData, otherFinestIndex, 256.0);\n\n    vec2 delta = myPosition.xy - otherPosition.xy;\n    float dist = max(length(delta), 0.0000001);\n    float maxDist = 25.0;\n    float repulsionForceScale = 0.1;\n\n    float area = getPeerFootprintArea(otherClusterData.w);\n    float F = (area * fScale) / (dist * dist);\n\n    if (isTopLevel) {\n      repulsionForceScale = 0.2;\n    }\n\n    acceleration += ((delta / sqrt(dist)) * F) * repulsionForceScale * otherClusterWeight * singleNodeRepulsionScale;\n\n    if (dist < maxDist) {\n      float collide = (maxDist - dist) / (dist * dist);\n      acceleration += delta * collide * fScale * maxDist / (maxDist + 1.0);\n    }\n  }\n\n  fragColor = vec4(acceleration, vec2(finestIndex, 0));\n}";
-export default _default;
+export { _default as default };

package/dist/types/layouts/forcedirectedlayout/shaders/multilevel-update-fragment.d.ts

@@ -1,2 +1,2 @@
 declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_physData;\nuniform sampler2D u_updateData;\nuniform float u_numNodesNew;\n\nout vec4 fragColor;\n\nconst float INDEX_FLAG = 999999.0;\n\nvec4 getTextureData(sampler2D tex, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture(tex, vec2(x + 0.5, y + 0.5) / base);\n}\n\nvoid main(void) {\n  float textureSide = 256.0; //#TEXTURE_SIDE#;\n  float index = (gl_FragCoord.x - 0.5) + (gl_FragCoord.y - 0.5)*textureSide;\n\n  if (index >= u_numNodesNew) {\n    discard;\n  }\n\n  float firstValue = getTextureData(u_updateData, index * 2.0, 256.0).r;\n  float secondValue = getTextureData(u_updateData, index * 2.0 + 1.0, 256.0).r;\n\n  if (secondValue == INDEX_FLAG) {\n    vec4 myPosition = getTextureData(u_physData, firstValue, 256.0);\n    fragColor = myPosition;\n  } else {\n    fragColor = vec4(firstValue, secondValue, 0.0, 0.0);\n  }\n}\n";
-export default _default;
+export { _default as default };

package/dist/types/layouts/forcedirectedlayout/shaders/sim-vertex.d.ts

@@ -1,2 +1,2 @@
 declare const _default: "#version 300 es\nuniform mat4 u_projection;\n\nin vec2 a_position;\n//in float a_index;\n\n//out highp float index;\n\nvoid main() {\n//  index = a_index;\n  gl_Position = u_projection * vec4(a_position, 0.0, 1.0);\n}";
-export default _default;
+export { _default as default };

package/dist/types/layouts/freeLayout/FreeLayout.d.ts

@@ -1,24 +1,24 @@
-import type { NvlState } from '../../modules/state/types';
-import type { Node, PartialNode } from '../../types/graph-element';
-import type { Point } from '../../utils/geometry';
+import { Point } from "../../utils/geometry.js";
+import { Node, PartialNode } from "../../types/graph-element.js";
+import { NvlState } from "../../modules/state/types.js";
 export declare class FreeLayout {
-    private state;
-    private positions;
-    private shouldUpdate;
-    private stateDisposers;
-    constructor(config: {
-        state: NvlState;
-    });
-    setOptions(): any;
-    updateNodes(positionList: PartialNode[]): void;
-    update(refreshPositions?: boolean): void;
-    layout(nodes: Node[], nodeIds: Record<string, Node>, idToPosition: Record<string, Node>): void;
-    setNodePositions(p: Record<string, Point>): void;
-    getNodePositions(nodeList: Node[]): (Point & {
-        id: string;
-    })[];
-    getShouldUpdate(): boolean;
-    getComputing(): boolean;
-    terminateUpdate(): any;
-    destroy(): void;
-}
+  private state;
+  private positions;
+  private shouldUpdate;
+  private stateDisposers;
+  constructor(config: {
+    state: NvlState;
+  });
+  setOptions(): any;
+  updateNodes(positionList: PartialNode[]): void;
+  update(refreshPositions?: boolean): void;
+  layout(nodes: Node[], nodeIds: Record<string, Node>, idToPosition: Record<string, Node>): void;
+  setNodePositions(p: Record<string, Point>): void;
+  getNodePositions(nodeList: Node[]): (Point & {
+    id: string;
+  })[];
+  getShouldUpdate(): boolean;
+  getComputing(): boolean;
+  terminateUpdate(): any;
+  destroy(): void;
+}

package/dist/types/layouts/gridLayout/GridLayout.d.ts

@@ -1,28 +1,28 @@
-import type { NvlState } from '../../modules/state/types';
-import type { Node, PartialNode } from '../../types/graph-element';
-import type { Point } from '../../utils/geometry';
+import { Point } from "../../utils/geometry.js";
+import { Node, PartialNode } from "../../types/graph-element.js";
+import { NvlState } from "../../modules/state/types.js";
 export declare class GridLayout {
+  state: NvlState;
+  positions: Record<string, Node & Point>;
+  stateDisposers: (() => void)[];
+  shouldUpdate: boolean;
+  constructor(config: {
     state: NvlState;
-    positions: Record<string, Node & Point>;
-    stateDisposers: (() => void)[];
-    shouldUpdate: boolean;
-    constructor(config: {
-        state: NvlState;
-    });
-    setOptions(): void;
-    updateNodes(positionList: PartialNode[]): void;
-    update(refreshPositions?: boolean): void;
-    layout(mobxNodes: any): void;
-    setNodePositions(idToPosition: Record<string, Node & Point>): void;
-    getNodePositions(nodeList: {
-        id: string;
-    }[]): {
-        id: string;
-        x: number;
-        y: number;
-    }[];
-    getShouldUpdate(): boolean;
-    getComputing(): boolean;
-    terminateUpdate(): void;
-    destroy(): void;
-}
+  });
+  setOptions(): void;
+  updateNodes(positionList: PartialNode[]): void;
+  update(refreshPositions?: boolean): void;
+  layout(mobxNodes: any): void;
+  setNodePositions(idToPosition: Record<string, Node & Point>): void;
+  getNodePositions(nodeList: {
+    id: string;
+  }[]): {
+    id: string;
+    x: number;
+    y: number;
+  }[];
+  getShouldUpdate(): boolean;
+  getComputing(): boolean;
+  terminateUpdate(): void;
+  destroy(): void;
+}

package/dist/types/layouts/hierarchicallayout/HierarchicalLayout.d.ts

@@ -1,32 +1,32 @@
-import { type HierarchicalOptions, type LayoutOptions, type NvlState } from '../../modules/state/types';
-import AnimatedLayout from '../animatedlayout/AnimatedLayout';
+import { HierarchicalOptions, LayoutOptions, NvlState } from "../../modules/state/types.js";
+import AnimatedLayout from "../animatedlayout/AnimatedLayout.js";
 type HierarchicalLayoutConfig = {
-    state: NvlState;
-    animationCompleteCallback?: () => void;
+  state: NvlState;
+  animationCompleteCallback?: () => void;
 } & HierarchicalOptions;
 export declare class HierarchicalLayout extends AnimatedLayout {
-    private direction;
-    private packing;
-    private clusterBy?;
-    private lastClusterByAssignments;
-    private stateDisposers;
-    private oldComputing;
-    private computing;
-    private pendingLayoutData;
-    private worker;
-    private directionChanged;
-    private packingChanged;
-    private clusterByChanged;
-    private workersDisabled;
-    constructor(config: HierarchicalLayoutConfig);
-    setOptions(options: LayoutOptions): void;
-    private applyClusterByOption;
-    private buildClusterAssignments;
-    update(refreshPositions?: boolean): void;
-    getShouldUpdate(): boolean;
-    getComputing(): boolean;
-    private layout;
-    terminateUpdate(): void;
-    destroy(): void;
+  private direction;
+  private packing;
+  private clusterBy?;
+  private lastClusterByAssignments;
+  private stateDisposers;
+  private oldComputing;
+  private computing;
+  private pendingLayoutData;
+  private worker;
+  private directionChanged;
+  private packingChanged;
+  private clusterByChanged;
+  private workersDisabled;
+  constructor(config: HierarchicalLayoutConfig);
+  setOptions(options: LayoutOptions): void;
+  private applyClusterByOption;
+  private buildClusterAssignments;
+  update(refreshPositions?: boolean): void;
+  getShouldUpdate(): boolean;
+  getComputing(): boolean;
+  private layout;
+  terminateUpdate(): void;
+  destroy(): void;
 }
-export {};
+export {};

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

@@ -1,4 +1,4 @@
-import type { HierarchicalOptions } from '../../modules/state/types';
+import { HierarchicalOptions } from "../../modules/state/types.js";
 export declare const Ranker = "tight-tree";
 export declare const SubGraphSpacing = 100;
 export declare const DirectionUp = "up";
@@ -8,4 +8,4 @@ export declare const DirectionRight = "right";
 export declare const Directions: Record<HierarchicalOptions['direction'], string>;
 export declare const PackingBin = "bin";
 export declare const PackingStack = "stack";
-export declare const Packings: HierarchicalOptions['packing'][];
+export declare const Packings: HierarchicalOptions['packing'][];

package/dist/types/modules/CallbackHelper.d.ts

@@ -1,4 +1,4 @@
-import { type ExternalCallbacks } from './ExternalCallbackHandler';
+import { ExternalCallbacks } from "./ExternalCallbackHandler.js";
 type CallbackFunction = ExternalCallbacks[keyof ExternalCallbacks];
 /**
  * A class for registering and calling callbacks
@@ -13,26 +13,26 @@ type CallbackFunction = ExternalCallbacks[keyof ExternalCallbacks];
  * ```
  */
 export declare class CallbackHelper {
-    private readonly callbacks;
-    constructor();
-    /**
-     * Register a callback function to be called when an event of that name happens
-     * @param name - The name of the callback to register.
-     * @param callback - A function that will be called when an event of that name happens.
-     * If other callbacks are already registered for that name it is added to the list
-     */
-    register(name: keyof ExternalCallbacks, callback: CallbackFunction): void;
-    /**
-     * Check if a callback function with that name is registered already
-     * @param name - The name of the callbacks to check.
-     * @return {boolean} Whether or not a callback function with that name is registered
-     */
-    isCallbackRegistered(name: keyof ExternalCallbacks): boolean;
-    /**
-     * Call all callbacks registered for a given name
-     * @param name - The name of the callbacks to call.
-     * @param data - Data to pass when calling the callbacks.
-     */
-    callIfRegistered(): void;
+  private readonly callbacks;
+  constructor();
+  /**
+   * Register a callback function to be called when an event of that name happens
+   * @param name - The name of the callback to register.
+   * @param callback - A function that will be called when an event of that name happens.
+   * If other callbacks are already registered for that name it is added to the list
+   */
+  register(name: keyof ExternalCallbacks, callback: CallbackFunction): void;
+  /**
+   * Check if a callback function with that name is registered already
+   * @param name - The name of the callbacks to check.
+   * @return {boolean} Whether or not a callback function with that name is registered
+   */
+  isCallbackRegistered(name: keyof ExternalCallbacks): boolean;
+  /**
+   * Call all callbacks registered for a given name
+   * @param name - The name of the callbacks to call.
+   * @param data - Data to pass when calling the callbacks.
+   */
+  callIfRegistered(): void;
 }
-export {};
+export {};