@neo4j-nvl/base 0.3.1-3ce43a8b

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

@@ -0,0 +1,167 @@
+export class PhysLayout {
+    constructor(config: any);
+    _physVbo: any;
+    _physSmallVbo: any;
+    _physProjection: mat4;
+    _physSmallProjection: mat4;
+    _gl: any;
+    _averageNodeSize: number;
+    shouldUpdate: boolean;
+    iterationCount: number;
+    lastSpeedValues: any[];
+    rollingAvgGraphSpeed: number;
+    nodeVariation: number;
+    nodeCenterPoint: number[];
+    peakIterationMultiplier: number;
+    stateDisposers: any[];
+    _state: any;
+    _dpr: number;
+    /**
+     * Sets the layout options
+     * @param {Object} options the object with the options
+     * @param {boolean} options.intelWorkaround whether to use the layout implementation for Intel GPUs
+     * @param {Number} options.simulationStopVelocity the graph speed at which to stop the layout
+     * @param {Number} options.gravity the force layout's gravity strength
+     * @param {boolean} [initial=false] whether this is the first setting of options
+     */
+    setOptions(options: {
+        intelWorkaround: boolean;
+        simulationStopVelocity: number;
+        gravity: number;
+    }, initial?: boolean): void;
+    intelWorkaround: boolean;
+    simulationStopVelocitySquared: number;
+    gravity: number;
+    force: any;
+    /**
+     * Sets graph data to be used
+     * @param {Object} data the graph object
+     * @param {Array<Object>} data.nodes the nodes in the graph
+     * @param {Array<Object>} data.rels the relationships in the graph
+     * @returns {Object} the top level graph of the subgraphs created by the solar merger
+     */
+    setData(data: {
+        nodes: Array<any>;
+        rels: Array<any>;
+    }): any;
+    _nodeIdToIndex: {};
+    _nodeIndexToId: {};
+    _numNodes: any;
+    solarMerger: SolarMerger;
+    subGraphs: any[];
+    nodeSortMap: {};
+    _firstUpdate: boolean;
+    _curPhysData: any;
+    /**
+     * Updates the node's positions for the next step in the physics layout iterations if the layout needs to update
+     * @param {boolean} refreshPositions whether the entire layout should be reheated
+     * @returns {boolean} whether the layout should update in the following step
+     */
+    update(refreshPositions: boolean): boolean;
+    collisionDetectionMultiplier: number;
+    /**
+     * Stops the layout
+     */
+    terminateUpdate(): void;
+    addedNodes: {};
+    /**
+     * Returns whether the current layout needs to be updated in the next iteration step.
+     * @returns {boolean} 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 {boolean} Whether the layout is computing.
+     */
+    getComputing(): boolean;
+    /**
+     * Adds the current x,y coordinates for each node to a given list of nodes.
+     * @param {Array<Object>} nodeList The list of nodes to get positions for.
+     * @returns {Array<Object>} The list of nodes containing the x,y coordinates on each node object.
+     */
+    getNodePositions(nodeList: Array<any>): Array<any>;
+    /**
+     * Reheats the layout
+     * @param {Object} fullData The entire graph object.
+     */
+    reheat(fullData: any): void;
+    /**
+     * Updates the existing nodes of a graph with a given list of updates
+     * @param {Array<Object>} nodeList The list of updates.
+     */
+    updateNodes(nodeList: Array<any>): void;
+    /**
+     * Adds and removes nodes from the graph based on given updates
+     * @param {Object} fullData The entire graph object.
+     * @param {Array<Object>} fullData.nodes the nodes in the graph
+     * @param {Array<Object>} fullData.rels the relationships in the graph
+     * @param {Object} nodeChanges The changes in the graph.
+     * @param {Array<Object>} nodeChanges.adds A list of nodes to be added.
+     * @param {Array<Object>} nodeChanges.removes A list of nodes to be removed.
+     */
+    addRemoveData(fullData: {
+        nodes: Array<any>;
+        rels: Array<any>;
+    }, nodeChanges: {
+        adds: Array<any>;
+        removes: Array<any>;
+    }): any;
+    _pinData: Uint8Array;
+    /**
+     * Destroys the class and all buffers and textures.
+     */
+    destroy(): void;
+    _physPositions: Float32Array;
+    _dumpTexture(framebuffer: any, numItems: any, msg: any): void;
+    _getScaleNumber(iterationNo: any, delayedDecayFormula?: (iterationNo: any, p: any, lowerBar: any) => any): any;
+    _getBaseLength(subGraphNodeCount: any): number;
+    _hasSizeChanged(updates?: any[]): boolean;
+    _checkForUpdates(fullRefresh?: boolean): void;
+    _getNodePosition(nodeIndex: any): {
+        x: any;
+        y: any;
+    };
+    _getMaxSpeedSquared(): number;
+    _getMedianSpeedSquared(addedNodes: any): number;
+    _getPhysData(offset?: number): any;
+    _getLevelData(offset?: number): any;
+    _newTexture(gl: any, data: any, side: any, type?: any, internalformat?: any): any;
+    _newFramebuffer(gl: any, texture: any): any;
+    _checkCompatibility(gl: any): void;
+    _useReadpixelWorkaround: boolean;
+    _printGlStats(gl: any): void;
+    _adjustToGlSize(size: any): number;
+    _setupSize(data?: {
+        nodes: any[];
+    }): void;
+    _sizeTexture: any;
+    _setupSprings(data: any): void;
+    connections: any;
+    _offsetTexture: any;
+    _springTexture: any;
+    _setupPhysics(): void;
+    _setupPhysicsForNodes(): void;
+    _physData: any[];
+    _physShader: Shader;
+    _setupPhysicsForCoarse(): void;
+    levelsData: any[];
+    levelsClusterTexture: any[];
+    levelsFinestIndexTexture: any[];
+    initalLevelTexture: any;
+    _apprxRepForceShader: Shader;
+    _setupPinData(): void;
+    _pinTexture: any;
+    _setupUpdates(): void;
+    _updateData: Float32Array;
+    _updateTexture: any;
+    _updateShader: Shader;
+    _setupReadpixelWorkaround(): void;
+    _workaroundShader: Shader;
+    _workaroundData: any[];
+    _doReadpixelWorkaround(): void;
+    _definePhysicsArrays(): void;
+}
+import { mat4 } from 'gl-matrix';
+import SolarMerger from './solarmerger/SolarMerger';
+import Shader from '../../../modules/Shader';

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

@@ -0,0 +1,4 @@
+export default class GlWrapper {
+    constructor(gl: any);
+    _wrapFunction(gl: any, functionName: any): (...args: any[]) => any;
+}

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

@@ -0,0 +1,2 @@
+declare const _default: "precision 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;\n\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 = 500000.0;\n\nvec4 getTextureData(sampler2D texture, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture2D(texture, 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).a;\n  return nodeSize + otherNodeSize;\n}\n\nvec2 getSpringForce(float curConnection,  float numConnections, float springFScale, vec4 myPosition, float i) {\n  float curSpring = getTextureData(u_connections, curConnection + i, 4096.0).a;\n\n  vec4 otherPosition = getTextureData(u_physData, curSpring, 256.0);\n  float otherDataPosition = getTextureData(u_connectionOffsets, curSpring, 256.0).a;\n  float avgDegree;\n#if INTEL_WORKAROUND\n    avgDegree = max(numConnections, 4.0);\n#else\n    float otherNumConnections = getTextureData(u_connections, otherDataPosition, 4096.0).a;\n    avgDegree = max((otherNumConnections + numConnections * 3.0) / 4.0, 4.0);\n#endif\n\n  vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n  float dist = length(delta);\n\n  float F = (dist * dist * springFScale) / (u_baseLength * avgDegree);\n  if (u_collisionMultiplier > 0.0) {\n    F *= u_collisionMultiplier;\n  }\n  return (-delta / dist) * F;\n}\n\nvec2 getCollisionForce(float combinedNodeSize, float dist, float fScale, vec2 delta) {\n  float collisionForce = ((combinedNodeSize - dist) / dist);\n  if (u_collisionMultiplier > 0.0) {\n    collisionForce *= u_collisionMultiplier;\n  }\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 / 1.5)) / dist;\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  float clusterWeight = clusterData.w;\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).a;\n  float nodeSize = getTextureData(u_sizeTexture, index, 256.0).a;\n\n  if (isPinned > 0.5) {\n    gl_FragColor = vec4(myPosition.xy, 0.0, 0.0);\n    return;\n  }\n\n  float curConnection = getTextureData(u_connectionOffsets, index, 256.0).a;\n  float numConnections = getTextureData(u_connections, curConnection, 4096.0).a;\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);\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      float combinedNodeSize = getCombinedNodeSize(i, nodeSize) * 2.0;\n\n      if (dist < combinedNodeSize && number_of_collisions < 40.0) {\n        number_of_collisions++;\n        acceleration += getCollisionForce(combinedNodeSize, dist, fScale, delta);\n      }\n\n      if (i >= clusterStartIndex && i < clusterStartIndex + clusterSize) {\n        acceleration += getRepulsionForce(dist, fScale, delta);\n      }\n    }\n  } else {\n    for (float i = 0.0; i < 256.0 * 256.0; i++) {\n      if (i >= clusterStartIndex + clusterSize || i >= u_numNodes) {\n        break;\n      }\n\n      if (i < clusterStartIndex || 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      float combinedNodeSize = getCombinedNodeSize(i, nodeSize);\n\n      if (dist < combinedNodeSize) {\n        acceleration += getCollisionForce(combinedNodeSize, dist, fScale, delta);\n      }\n\n      acceleration += getRepulsionForce(dist, fScale, delta);\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;\n  acceleration += grav * smoothstep(0.0, 500.0, dist);\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  if (u_curIteration == 0.0) {\n    gl_FragColor = vec4(myPosition.xy, acceleration * TIMESTEP * 0.5);\n  } else {\n    myPosition.zw = myPosition.zw * VELOCITYDECAY;\n    gl_FragColor = vec4(myPosition.xy + myPosition.zw * TIMESTEP, myPosition.zw + acceleration * TIMESTEP);\n  }\n}";
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: "precision 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\nfloat TIMESTEP = 1.0 / 30.0;\nfloat VELOCITYDECAY = 0.6;\n\nvec4 getTextureData(sampler2D texture, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture2D(texture, vec2(x + 0.5, y + 0.5) / base);\n}\n\nfloat getLogClusterWeight(float value) {\n  return value / max(log(value), 1.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\n  float clusterIndex = clusterData.x;\n  float clusterStartIndex = clusterData.y;\n  float clusterSize = clusterData.z;\n\n  float finestIndex = getTextureData(u_finestIndexes, index, 256.0).a;\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  // Repulsion & Collision Detection\n  for (float i = 0.0; i < 256.0 * 256.0; i++) {\n    if (i >= clusterStartIndex + clusterSize || i >= u_numNodes) {\n      break;\n    }\n    if (i < clusterStartIndex || i == index) {\n      continue;\n    }\n\n    vec4 otherClusterData = getTextureData(u_clusterData, i, 256.0);\n    float otherClusterWeight = getLogClusterWeight(otherClusterData.w);\n\n    float otherFinestIndex = getTextureData(u_finestIndexes, i, 256.0).a;\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 F = ((u_baseLength * u_baseLength) * (fScale / 1.5)) / dist;\n\n    if (u_isTopLevel == 1.0) {\n      repulsionForceScale = 0.3;\n    }\n\n    acceleration += ((delta / dist) * F) * repulsionForceScale * otherClusterWeight;\n\n    if (dist < maxDist) {\n      float collide = (maxDist - dist) / dist;\n      acceleration += delta * collide * fScale * maxDist / (maxDist + 1.0);\n    }\n  }\n\n  gl_FragColor = vec4(acceleration, vec2(finestIndex, 0));\n}";
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: "precision mediump float;\n\nuniform sampler2D u_physData;\nuniform sampler2D u_updateData;\nuniform float u_numNodesNew;\n\nconst float INDEX_FLAG = 999999.0;\n\nvec4 getTextureData(sampler2D texture, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture2D(texture, 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).a;\n  float secondValue = getTextureData(u_updateData, index * 2.0 + 1.0, 256.0).a;\n\n  if (secondValue == INDEX_FLAG) {\n    vec4 myPosition = getTextureData(u_physData, firstValue, 256.0);\n    gl_FragColor = myPosition;\n  } else {\n    gl_FragColor = vec4(firstValue, secondValue, 0.0, 0.0);\n  }\n}\n";
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: "uniform mat4 u_projection;\n\nattribute vec2 a_position;\n//attribute float a_index;\n\n//varying 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;

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

@@ -0,0 +1,2 @@
+declare const _default: "precision lowp float;\n\nuniform sampler2D u_physData;\nuniform float u_index;\n\nfloat shift_right (float v, float amt) { \n    v = floor(v) + 0.5; \n    return floor(v / exp2(amt)); \n}\n\nfloat shift_left (float v, float amt) { \n    return floor(v * exp2(amt) + 0.5); \n}\n\nfloat mask_last (float v, float bits) { \n    return mod(v, shift_left(1.0, bits)); \n}\n\nfloat extract_bits (float num, float from, float to) { \n    from = floor(from + 0.5); to = floor(to + 0.5); \n    return mask_last(shift_right(num, from), to - from); \n}\n\n// From https://stackoverflow.com/questions/17981163/webgl-read-pixels-from-floating-point-render-target\nvec4 encode_float (float val) { \n    if (val == 0.0) return vec4(0, 0, 0, 0); \n    float sign = val > 0.0 ? 0.0 : 1.0; \n    val = abs(val); \n    float exponent = floor(log2(val)); \n    float biased_exponent = exponent + 127.0; \n    float fraction = ((val / exp2(exponent)) - 1.0) * 8388608.0; \n    float t = biased_exponent / 2.0; \n    float last_bit_of_biased_exponent = fract(t) * 2.0; \n    float remaining_bits_of_biased_exponent = floor(t); \n    float byte4 = extract_bits(fraction, 0.0, 8.0) / 255.0; \n    float byte3 = extract_bits(fraction, 8.0, 16.0) / 255.0; \n    float byte2 = (last_bit_of_biased_exponent * 128.0 + extract_bits(fraction, 16.0, 23.0)) / 255.0; \n    float byte1 = (sign * 128.0 + remaining_bits_of_biased_exponent) / 255.0; \n    return vec4(byte4, byte3, byte2, byte1); \n}\n\nvoid main(void) {\n  vec4 texData = texture2D(u_physData, gl_FragCoord.xy / 255.0);\n  float data;\n  if (u_index == 0.0) {\n    data = texData.x;\n  } else if (u_index == 1.0) {\n    data = texData.y;\n  } else if (u_index == 2.0) {\n    data = texData.z;\n  } else if (u_index == 3.0) {\n    data = texData.w;\n  }\n\n  gl_FragColor = encode_float(data);\n}\n";
+export default _default;

package/dist/types/layouts/forcedirectedlayout/physlayout/solarmerger/SolarMerger.d.ts

@@ -0,0 +1,43 @@
+export default class SolarMerger {
+    constructor(graph: any, nodeIdToIndex: any);
+    graph: {
+        nodes: any[];
+        relationships: any[];
+        idToRel: {};
+    };
+    subGraphs: any[];
+    sunMap: {};
+    constructGraphObjects(graph: any, nodeIdToIndex: any): {
+        nodes: any[];
+        relationships: any[];
+        idToRel: {};
+    };
+    relIdMap: any[];
+    coarsenTo(targetSize: any): {
+        nodes: any[];
+        relationships: any[];
+        idToRel: {};
+    };
+    nodeSortMap: {};
+    coarsenBy(level: any): {
+        nodes: any[];
+        relationships: any[];
+        idToRel: {};
+    };
+    coarsen({ nodes, relationships }: {
+        nodes: any;
+        relationships: any;
+    }, firstIteration: any): {
+        output: {
+            nodes: {
+                id: any;
+            }[];
+            relationships: any[];
+        };
+        sortedInput: {
+            nodes: any[];
+            relationships: any[];
+        };
+        nodeSortMap: {};
+    };
+}

package/dist/types/layouts/forcedirectedlayout/physlayout/solarmerger/solar-placer.d.ts

@@ -0,0 +1,4 @@
+export function calculatePositions(centre: any, r: any, noOfChildren: any): {
+    x: any;
+    y: any;
+}[];

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

@@ -0,0 +1,26 @@
+import type { NvlState } from '../../modules/state';
+import type { Node } from '../../types/graph-element';
+import type { Point } from '../../utils/geometry';
+export declare class FreeLayout {
+    private state;
+    private positions;
+    private shouldUpdate;
+    private stateDisposers;
+    constructor(config: {
+        state: NvlState;
+    });
+    setOptions(): any;
+    updateNodes(positionList: (Point & {
+        id: string;
+    })[]): 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

@@ -0,0 +1,16 @@
+export class GridLayout {
+    constructor(config: any);
+    state: any;
+    positions: {};
+    stateDisposers: any[];
+    shouldUpdate: boolean;
+    setOptions(options: any): void;
+    updateNodes(positionList: any): void;
+    update(refreshPositions?: boolean): void;
+    layout(nodes: any, nodeIds: any, idToPosition: any, rels: any): void;
+    getNodePositions(nodeList: any): any[];
+    getShouldUpdate(): boolean;
+    getComputing(): boolean;
+    terminateUpdate(): void;
+    destroy(): void;
+}

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

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

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

@@ -0,0 +1,11 @@
+import type { HierarchicalOptions } from '../../modules/state';
+export declare const Ranker = "tight-tree";
+export declare const SubGraphSpacing = 100;
+export declare const DirectionUp = "up";
+export declare const DirectionDown = "down";
+export declare const DirectionLeft = "left";
+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'][];

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

@@ -0,0 +1,38 @@
+import type { ExternalCallbacks } from './ExternalCallbackHandler';
+type CallbackFunction = ExternalCallbacks['onError'] | ExternalCallbacks['onLayoutComputing'] | ExternalCallbacks['onLayoutDone'] | ExternalCallbacks['onLayoutStep'];
+/**
+ * A class for registering and calling callbacks
+ * @example
+ * ```
+ * const callbackHelper = new CallbackHelper()
+ * callbackHelper.register('myEvent', (data) => {
+ *  console.log(data)
+ * })
+ * callbackHelper.callIfRegistered('myEvent', 'Hello World')
+ * // Logs 'Hello World'
+ * ```
+ */
+export default class CallbackHelper {
+    private readonly callbacks;
+    constructor();
+    /**
+     * Register a callback function to be called when an event of that name happens
+     * @param {string} name The name of the callback to register
+     * @param {function} callback A function that will be called when an event of that name happens
+     * @note 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 {string} 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 {string} name - The name of the callbacks to call
+     * @param {object} data - Data to pass when calling the callbacks
+     */
+    callIfRegistered(): void;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import type { Node } from '../types/graph-element';
+/**
+ * An object specifying the required callback functions for certain actions
+ */
+export interface ExternalCallbacks {
+    /** Triggered when a layout is done moving. */
+    onLayoutDone?: () => void;
+    /** Triggered on each step of a layout. */
+    onLayoutStep?: (p: Node[]) => void;
+    /** Triggered when NVL throws an error after initialization. */
+    onError?: (error: Error) => void;
+    /** Triggered when a asynchronous layout calculation starts/stops. */
+    onLayoutComputing?: (isComputing: boolean) => void;
+    onWebGLContextLost?: (webGLContextEvent: WebGLContextEvent) => void;
+}
+export default class ExternalCallbackHandler {
+    callbacks: ExternalCallbacks;
+    constructor(externalCallbacks?: ExternalCallbacks);
+    onLayoutDone(): void;
+    onLayoutStep(p: Node[]): void;
+    onLayoutComputing(isComputing: boolean): void;
+    onError(error: Error): void;
+    onWebGLContextLost(webGLContextEvent: WebGLContextEvent): void;
+    private isValidFunction;
+}

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

@@ -0,0 +1,119 @@
+export const EVENT_ERROR: "onError";
+export const EVENT_LAYOUT_DONE: "onLayoutDone";
+export const EVENT_LAYOUT_STEP: "onLayoutStep";
+export const EVENT_LAYOUT_COMPUTING: "onLayoutComputing";
+export const EVENT_WEBGL_CONTEXT_LOST: "onWebGLContextLost";
+export default class NvlController {
+    constructor(state: any, options?: {});
+    destroyed: boolean;
+    _state: any;
+    _callbacks: CallbackHelper;
+    instanceId: any;
+    _glController: GLController | DummyGLController;
+    _webGLContext: RenderingContext;
+    _webGLMinimapContext: RenderingContext;
+    _htmlOverlay: HTMLDivElement;
+    _hasResized: boolean;
+    _hierLayout: HierarchicalLayout;
+    _gridLayout: GridLayout;
+    _freeLayout: FreeLayout;
+    _d3ForceLayout: d3ForceLayout;
+    _forceLayout: d3ForceLayout | ForceCytoLayout;
+    _canvasRenderer: CanvasRenderer;
+    _c2dContext: CanvasRenderingContext2D;
+    _glCanvas: HTMLCanvasElement;
+    _canvasRect: DOMRect;
+    _glMinimapCanvas: HTMLCanvasElement;
+    _c2dCanvas: HTMLCanvasElement;
+    _isInRenderSwitchAnimation: boolean;
+    _justSwitchedRenderer: boolean;
+    _justSwitchedLayout: boolean;
+    _layoutUpdating: boolean;
+    _layoutComputing: boolean;
+    isRenderingDisabled: boolean;
+    setRenderSwitchAnimation: () => void;
+    stateDisposers: any[];
+    _zoomTransitionHandler: ZoomTransitionHandler;
+    layoutTimeLimit: any;
+    forceWebGLThreshold: any;
+    pixelRatio: number;
+    removeResizeListener: any;
+    removeMinimapResizeListener: any;
+    pendingZoomOperation: (() => any) | (() => any) | (() => any) | (() => any);
+    _onWebGLContextLost(webGLContextEvent: any): void;
+    _updateMinimapZoom(): void;
+    _startMainloop(): void;
+    _layoutRunner: NodeJS.Timeout;
+    animationRequestId: number;
+    updateHtmlOverlay(): void;
+    dumpNodes(): any[];
+    dumpRelationships(): any;
+    /**
+     * Map a relative Canvas space to the DOM position
+     * @param {number} canvasX X position in the canvas space
+     * @param {number} canvasY Y position position in the canvas space
+     */
+    mapCanvasSpaceToRelativePosition(canvasX: number, canvasY: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Map a relative DOM position to the Canvas space
+     * @param {*} clientX relative X position from the top left [0..rect.width]
+     * @param {*} clientY relative Y position from the top left [0..rect.height]
+     */
+    mapRelativePositionToCanvasSpace(clientX: any, clientY: any): {
+        x: any;
+        y: any;
+    };
+    getNodePositions(): any[];
+    setNodePositions(data: any, updateLayout?: boolean): void;
+    isLayoutMoving(): boolean;
+    getNodesOnScreen(): {
+        nodes: import("..").Node[];
+        rels: import("..").Relationship[];
+    };
+    registerDoneCallback(cb: any): void;
+    _layoutDoneCallback: any;
+    registerComputingCallback(cb: any): void;
+    _layoutComputingCallback: any;
+    getPosition(nodeId: any): any;
+    addCanvasOptions(options: any): void;
+    setNodeInformationLevel(viewLevel: any): void;
+    setEdgeInformationLevel(viewLevel: any): void;
+    getScale(): any;
+    getPan(): {
+        x: any;
+        y: any;
+    };
+    setZoomLevel(_newLevel: any): void;
+    setPanCoordinates(panX: any, panY: any): void;
+    setZoomAndPan(zoom: any, panX: any, panY: any): void;
+    fit(nodeIds: any, zoomOptions: any): void;
+    resetZoom(): void;
+    setRenderer(renderer: any): void;
+    on(name: any, callback: any): void;
+    destroy(): void;
+    callIfRegistered(...args: any[]): void;
+    getCanvasRelsAt(point: any): import("../utils/hittest").HitTargetRelationship[];
+    getCanvasNodesAt(point: any, hitNodeMarginWidth?: number): import("../utils/hittest").HitTargetNode[];
+    _getLayout(layoutType: any): d3ForceLayout | ForceCytoLayout;
+    setLayout(layoutType: any): void;
+    _currentLayout: d3ForceLayout | ForceCytoLayout;
+    _currentLayoutType: any;
+    setLayoutOptions(options: any): void;
+    createDownloadLink(filename: any, canvas: any): HTMLAnchorElement;
+    saveToFile(options: any): void;
+    prepareLargeFileForDownload(options: any): Promise<any>;
+    saveFullGraphToLargeFile(options: any): Promise<void>;
+}
+import CallbackHelper from './CallbackHelper';
+import GLController from '../renderers/webglrenderer/Controller';
+import { DummyController as DummyGLController } from '../renderers/webglrenderer/Controller';
+import { HierarchicalLayout } from '../layouts/hierarchicallayout/HierarchicalLayout';
+import { GridLayout } from '../layouts/gridLayout/GridLayout';
+import { FreeLayout } from '../layouts/freeLayout/FreeLayout';
+import { d3ForceLayout } from '../layouts/d3forcelayout/d3ForceLayout';
+import { ForceCytoLayout } from '../layouts/forcedirectedlayout/ForceCytoLayout';
+import CanvasRenderer from '../renderers/canvasrenderer/CanvasRenderer';
+import ZoomTransitionHandler from './ZoomTransitionHandler';

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

@@ -0,0 +1,18 @@
+export default class Shader {
+    constructor(gl: any, vsSource: any, fsSource: any, defines?: {});
+    _shaderProgram: any;
+    _gl: any;
+    _curTexture: number;
+    _scanAttributes(): void;
+    _attributeInfo: {};
+    _scanUniforms(): void;
+    _uniformInfo: {};
+    setUniform(name: any, value: any): void;
+    setAttributePointer(name: any, size: any, start: any, stride: any): void;
+    setAttributePointerFloat(name: any, size: any, start: any, stride: any): void;
+    setAttributePointerUShort(name: any, size: any, start: any, stride: any): void;
+    setAttributePointerByteNorm(name: any, size: any, start: any, stride: any): void;
+    setAttributePointerByte(name: any, size: any, start: any, stride: any): void;
+    use(): void;
+    remove(): void;
+}

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

@@ -0,0 +1,27 @@
+import PIDController from 'node-pid-controller';
+import type { Node } from '../types/graph-element';
+import type { NvlState } from './state';
+export default class ZoomTransitionHandler {
+    xCtrl: PIDController;
+    yCtrl: PIDController;
+    zoomCtrl: PIDController;
+    private getNodePositions;
+    private firstUpdate;
+    private readonly state;
+    private readonly canvas;
+    private readonly defaultZoomLevel;
+    private readonly stateDisposers;
+    constructor({ state, getNodePositions, canvas, defaultZoomLevel }: {
+        state: NvlState;
+        getNodePositions: () => Node[];
+        canvas: HTMLCanvasElement;
+        defaultZoomLevel: number;
+    });
+    needsToRun(): boolean;
+    update(layoutActive: boolean): void;
+    destroy(): void;
+    private recalculateTarget;
+    private allNodesAreVisible;
+    private reset;
+    private fitNodes;
+}

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

@@ -0,0 +1,37 @@
+import type { Node, Relationship } from '../types/graph-element';
+import type { Point } from '../utils/geometry';
+/** A graph stored with mobx. */
+export interface DataSet<T> {
+    items: T[];
+    idToItem: Record<string, T>;
+    channels: Record<string, Channel<T>>;
+    idToPosition: Record<string, Node & Point>;
+    idToHtmlOverlay?: Record<string, HTMLElement>;
+    version: number;
+    addChannel: (this: DataSet<T>, channelName: string) => void;
+    removeChannel: (this: DataSet<T>, channelName: string) => void;
+    clearChannel: (this: DataSet<T>, channelName: string) => void;
+    add: (data: T[], result: ActionResult) => void;
+    update: (data: Partial<T>[], result: ActionResult) => void;
+    remove: (ids: string[], result: ActionResult) => void;
+    updatePositions: (data: Node[]) => void;
+    updateHtmlOverlay: (overlay: HTMLElement) => void;
+}
+export type NodeDataSet = DataSet<Node>;
+export type RelationshipDataSet = DataSet<Relationship>;
+export interface ActionResult {
+    added?: boolean;
+    removed?: boolean;
+    updated?: boolean;
+}
+export interface Channel<T> {
+    adds: Record<string, T>;
+    updates: Record<string, T>;
+    removes: Record<string, T>;
+}
+export declare const getHtmlProperty: (item: Partial<Node | Relationship>) => HTMLElement | undefined;
+/**
+ * Creates an empty dataset in which a graph be stored and updated using mobx actions.
+ * @returns A new and empty {@link DataSet}
+ */
+export declare const createDataSet: <T extends Node | Relationship>() => DataSet<T>;

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

@@ -0,0 +1,5 @@
+export function setLogLevel(level: any): void;
+export function setupLogging(logger: any, logging: any): void;
+export { nvlLog as log };
+declare const nvlLog: loglevel.Logger;
+import loglevel from 'loglevel';