@neo4j-nvl/base 1.2.1 → 2.0.0

package/dist/types/renderers/ClusterOverlay.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/renderers/domrenderer/shared/ImageCache.d.ts

@@ -4,6 +4,7 @@ declare class ImageCache {
     private readonly onImageLoadedCb?;
     constructor(onImageLoaded?: () => void);
     getImage(src: string, inverted?: boolean): HTMLCanvasElement;
+    isDrawn(src: string, inverted?: boolean): boolean;
     private getOrCreateEntry;
     private invertCanvas;
     private loadImage;

package/dist/types/renderers/domrenderer/shared/types.d.ts

@@ -11,8 +11,7 @@ export type TextSegment = {
  */
 export type StyledCaption = {
     /**
-     * The font styles as an array of style keywords.
-     * @example `['bold', 'italic']`
+     * The font styles as an array of style keywords, e.g. `['bold', 'italic']`.
      */
     styles?: string[];
     /** The text value for the caption. */

package/dist/types/renderers/webglrenderer/Controller.d.ts

@@ -10,8 +10,10 @@ export interface ControllerInterface {
     stateDisposers: NvlState['autorun'][];
     state: NvlState;
     needsToRun: () => boolean;
-    renderMainScene: (positionArray: Node[]) => void;
-    renderMinimap: (positionArray: Node[]) => void;
+    renderMainScene: (positionArray: Node[], positionsChanged?: boolean) => void;
+    renderMainSceneFromTexture: (positionTexture: WebGLTexture) => void;
+    setPositionTexelIndices: (map: Readonly<Record<string, number>> | null) => void;
+    renderMinimap: (positionArray: Node[], positionsChanged?: boolean) => void;
     checkForUpdates: (nodes: DataSet<Node>, rels: DataSet<Relationship>) => void;
     onResize: () => void;
     updateMainViewport: (zoom: number, panX: number, panY: number) => void;
@@ -34,8 +36,25 @@ export default class Controller implements ControllerInterface {
         state?: NvlState;
     });
     needsToRun(): boolean;
-    renderMainScene(positionArray: Node[]): void;
-    renderMinimap(positionArray: Node[]): void;
+    renderMainScene(positionArray: Node[], positionsChanged?: boolean): void;
+    /**
+     * Renders the main scene from a GPU position texture instead of a
+     * CPU position array, avoiding the readback + upload round trip.
+     * @param positionTexture - Live GPU node-position texture to render from.
+     */
+    renderMainSceneFromTexture(positionTexture: WebGLTexture): void;
+    /**
+     * Sets the node-id -> texel-index map for the main scene renderer so it
+     * samples a shared position texture in the layout's order. Pass null to use
+     * insertion order.
+     * @param map - The node-id-to-texel-index map, or null.
+     *
+     * @note The minimap keeps insertion-order sampling and uploads lagged CPU
+     * positions (async PhysLayout cache) while the main scene may sample the
+     * shared GPU texture.
+     */
+    setPositionTexelIndices(map: Readonly<Record<string, number>> | null): void;
+    renderMinimap(positionArray: Node[], positionsChanged?: boolean): void;
     checkForUpdates(nodes: DataSet<Node>, rels: DataSet<Relationship>): void;
     onResize(): void;
     updateMainViewport(zoom: number, panX: number, panY: number): void;
@@ -52,8 +71,10 @@ export declare class DummyController implements ControllerInterface {
     minimapMouseDown: boolean;
     stateDisposers: NvlState['autorun'][];
     state: NvlState;
-    renderMainScene(positionArray: Node[]): void;
-    renderMinimap(positionArray: Node[]): void;
+    renderMainScene(positionArray: Node[], positionsChanged?: boolean): void;
+    renderMainSceneFromTexture(positionTexture: WebGLTexture): void;
+    setPositionTexelIndices(map: Readonly<Record<string, number>> | null): void;
+    renderMinimap(positionArray: Node[], positionsChanged?: boolean): void;
     checkForUpdates(nodes: DataSet<Node>, rels: DataSet<Relationship>): void;
     onResize(): void;
     updateMainViewport(zoom: number, panX: number, panY: number): void;

package/dist/types/renderers/webglrenderer/IconLayerRegistry.d.ts

@@ -0,0 +1,14 @@
+export declare const MaxIconLayers = 256;
+/**
+ * Maps icon URLs to stable layer indices for a WebGL `sampler2DArray`.
+ * Delegates image loading and rasterization to {@link ImageCache}.
+ */
+export declare class IconLayerRegistry {
+    private readonly imageCache;
+    private readonly layerMap;
+    constructor(onImageLoaded?: () => void);
+    getLayer(url: string, inverted: boolean): number | null;
+    hasLoadingLayers(): boolean;
+    layerCount(): number;
+    getAvailableCanvases(): Map<number, HTMLCanvasElement>;
+}

package/dist/types/renderers/webglrenderer/IconLayerRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/renderers/webglrenderer/Renderer.d.ts

@@ -2,11 +2,17 @@ import { mat4 } from 'gl-matrix';
 import type { DataSet } from '../../modules/dataset';
 import type { NvlState } from '../../modules/state/types';
 import type { Node, Relationship } from '../../types/graph-element';
+export type RendererOptions = {
+    enableIcons?: boolean;
+};
 export default class Renderer {
     private readonly nodeShader;
     private readonly nodeAnimShader;
     private readonly relShader;
+    private readonly arrowShader;
     private relDataBuffer;
+    private arrowDataBuffer;
+    private arrowData;
     private readonly viewportBoxShader;
     private readonly defaultRelColor;
     private readonly defaultNodeColor;
@@ -14,39 +20,73 @@ export default class Renderer {
     private readonly disableNodeColor;
     private readonly gl;
     activeNodes: Record<string, boolean>;
+    numActiveNodes: number;
     readonly canvas: HTMLCanvasElement;
     projection: mat4;
     private idToIndex;
+    /** Node-id → texel-index map for GPU-shared rendering; null falls back to insertion order. */
+    private texelIndexForId;
+    /** texelIndexForId value when vertex buffers were last built; used to detect changes in the texel-index mapping. */
+    private texelMapAtBuild;
+    private lastNodes;
+    private lastBundledRels;
+    private idToSize;
     private posBuffer;
+    private positionsDirty;
     private numRels;
     private numNodes;
     private nodeDataByte;
     private relIdToIndex;
     private relData;
     private viewportBoxBuffer;
+    private readonly viewportBoxVertices;
     private relBuffer;
+    private arrowBuffer;
     private nodeBuffer;
     private posTexture;
+    private iconTexture;
     private nodeVao;
     private relVao;
+    private arrowVao;
     private nodeAnimVao;
-    private vaoExt;
-    constructor(gl: WebGLRenderingContext, nodes: DataSet<Node>, rels: DataSet<Relationship>, state: NvlState);
+    private readonly iconLayers;
+    private uploadedIconLayers;
+    private nodeColors;
+    private nodeDisabled;
+    constructor(gl: WebGL2RenderingContext, nodes: DataSet<Node>, rels: DataSet<Relationship>, state: NvlState, options?: RendererOptions);
     private setShaderUniforms;
     setData(data: {
         nodes: Node[];
         rels: Relationship[];
     }): void;
-    render(positionArray: Node[]): void;
+    /** Sets the texel-index map for GPU-shared rendering, or null for insertion order. */
+    setPositionTexelIndices(map: Readonly<Record<string, number>> | null): void;
+    /** Texel index for a node id; falls back to insertion index, or 0 if the id is unknown. */
+    private getTexelIndex;
+    /**
+     * Rebuilds vertex buffers when the texel-index mapping has changed since the last build.
+     */
+    private rebuildBuffersIfTexelMappingChanged;
+    render(positionArray: Node[], positionsChanged?: boolean): void;
+    /** Renders using a GPU position texture directly as `u_positions` */
+    renderFromGpuTexture(positionTexture: WebGLTexture): void;
+    private renderRelationships;
     renderViewbox(): void;
     updateNodes(updates: Node[]): void;
     updateRelationships(relItems: Relationship[]): void;
     private createPositionTexture;
+    private createIconTexture;
+    private uploadPendingIconLayers;
+    hasPendingIcons(): boolean;
     updateViewportBox(zoom: number, panX: number, panY: number, viewportWidth: number, viewportHeight: number): void;
     updateViewport(zoom: number, panX: number, panY: number): void;
     private setupViewportRendering;
+    private resolveNodeColor;
     private setupNodeRendering;
     private setupRelationshipRendering;
+    private setupArrowRendering;
+    private getRelBufferAttributes;
+    private updateEndpointSizesForNode;
     private renderAnimations;
     destroy(): void;
 }

package/dist/types/renderers/webglrenderer/node-animation-fragment.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mediump float u_zoom;\nuniform lowp float u_animPos;\nuniform mediump float u_glAdjust;\n\nvarying lowp vec4 color;\nvarying lowp float varNodeSize;\nmediump float circleSize = 0.50;\n\nvoid main(void) {\n\n  lowp float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  }\n  else {\n    lowp float alpha = 1.0 - smoothstep(circleSize - (1.0 / (varNodeSize * 2.0 * u_zoom * u_glAdjust)), circleSize, dist);\n    lowp float pulseAlpha = 0.9 - 0.9 * u_animPos;\n    gl_FragColor = vec4(color.xyz, 1.0) * alpha * pulseAlpha;\n  }\n}\n";
+declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform mediump float u_zoom;\nuniform lowp float u_animPos;\nuniform mediump float u_glAdjust;\n\nin lowp vec4 color;\nin mediump float varNodeSize;\n\nout vec4 fragColor;\n\nconst float pulseCircleEdge = 0.50;\n\nvoid main(void) {\n  float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  } else {\n    float alpha = 1.0 - smoothstep(pulseCircleEdge - (1.0 / (varNodeSize * 2.0 * u_zoom * u_glAdjust)), pulseCircleEdge, dist);\n    float pulseAlpha = 0.9 - 0.9 * u_animPos;\n    fragColor = vec4(color.xyz, 1.0) * alpha * pulseAlpha;\n  }\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/node-animation-vertex.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform lowp float u_animPos;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nattribute float a_size;\nattribute lowp vec2 a_index;\nattribute lowp vec4 a_color;\nattribute lowp float a_active;\n\nvarying lowp float varNodeSize;\nvarying lowp vec4 color;\n\nvoid main(void) {\n  vec4 data = texture2D(u_positions, a_index);\n\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  float nodeSize = a_size * u_zoom * u_glAdjust;\n  nodeSize = nodeSize * (0.4 / 0.5); // Remove extra space added for shadow and selection ring\n\n  gl_PointSize = a_active > 0.5\n    ? nodeSize + 0.88 * nodeSize * u_animPos\n    : 0.0;\n\n  color = a_color;\n  varNodeSize = a_size;\n}";
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform lowp float u_animPos;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nin float a_size;\nin highp vec2 a_index;\nin lowp vec4 a_color;\nin lowp float a_active;\n\nout mediump float varNodeSize;\nout lowp vec4 color;\n\nvoid main(void) {\n  vec4 data = texture(u_positions, a_index);\n\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  float nodeSize = a_size * u_zoom * u_glAdjust;\n  nodeSize = nodeSize * 0.8;\n\n  gl_PointSize = a_active > 0.5\n    ? nodeSize + 0.88 * nodeSize * u_animPos\n    : 0.0;\n\n  color = a_color;\n  varNodeSize = a_size;\n}";
 export default _default;

package/dist/types/renderers/webglrenderer/node-fragment-point.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nvarying lowp vec4 color;\nvarying lowp float drawDefaultBorder;\nvarying lowp vec3 nodeBorderColor;\nvarying lowp vec3 selectedBorderColor;\nvarying lowp vec3 selectedInnerBorderColor;\nvarying lowp vec3 shadowColor;\nvarying lowp float selected;\nvarying lowp float hovered;\nvarying lowp float varNodeSize;\n\nmediump float circleSize = 0.40;\nmediump float defaultBoderSize = 0.42;\nmediump float innerSelectedRingSize = 0.43;\nmediump float outerSelectedRingSize = 0.47;\nmediump float shadowSize = 0.51;\n\nlowp float getShadowAlpha(lowp float size, lowp float dist) {\n  return (1.0 - smoothstep(size, shadowSize, dist)) * 0.25;\n}\n\nlowp float getCircleAlpha(lowp float ringSize, lowp float nodeSize, lowp float dist) {\n  return color.w - smoothstep(ringSize - nodeSize, ringSize, dist);\n}\n\nvoid main() {\n  lowp float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  }\n  else {\n    lowp float nodeSize = 1.0 / varNodeSize;\n    lowp float nodeAlpha = getCircleAlpha(circleSize, nodeSize, dist);\n    lowp float borderAlpha = getCircleAlpha(defaultBoderSize, nodeSize, dist);\n    lowp float ringAlpha = getCircleAlpha(innerSelectedRingSize, nodeSize, dist);\n    lowp vec3 finalColor = color.xyz;\n    lowp float finalAlpha = nodeAlpha;\n\n    if (selected > 0.0) {\n      lowp float shadowAlpha = getShadowAlpha(outerSelectedRingSize, dist);\n      lowp float ringAlpha2 = getCircleAlpha(outerSelectedRingSize, nodeSize, dist);\n\n      if (drawDefaultBorder > 0.0) {\n        finalColor = mix(nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(selectedInnerBorderColor, finalColor, borderAlpha);\n        finalColor = mix(selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(borderAlpha, ringAlpha2)));\n      } else {\n        finalColor = mix(selectedInnerBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(ringAlpha, ringAlpha2)));\n      }\n    } else if (hovered > 0.0) {\n      if (drawDefaultBorder > 0.0) {\n        lowp float shadowAlpha = getShadowAlpha(defaultBoderSize, dist);\n  \n        finalColor = mix(nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(shadowColor, finalColor, borderAlpha);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, ringAlpha));\n      } else {\n        lowp float shadowAlpha = getShadowAlpha(circleSize, dist);\n\n        finalColor = mix(shadowColor, finalColor, nodeAlpha);\n        finalAlpha = max(shadowAlpha, nodeAlpha);\n      }\n    } else {\n      if (drawDefaultBorder > 0.0) {\n        finalColor = mix(nodeBorderColor, finalColor, nodeAlpha);\n        finalAlpha = borderAlpha;\n      }\n    }\n    gl_FragColor = vec4(finalColor, 1.0) * finalAlpha;\n  }\n}\n";
+declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform lowp vec3 u_nodeBorderColor;\nuniform lowp vec3 u_selectedBorderColor;\nuniform lowp vec3 u_selectedInnerBorderColor;\nuniform lowp vec3 u_shadowColor;\nuniform lowp float u_drawDefaultBorder;\nuniform lowp sampler2DArray u_icons;\nuniform mediump float u_minIconScreenPx;\n\nin lowp vec4 color;\nin lowp float selected;\nin lowp float hovered;\nin mediump float varNodeSize;\nin mediump float iconLayer;\nin lowp float hasIcon;\n\nout vec4 fragColor;\n\nconst float circleSize = 0.40;\nconst float defaultBorderSize = 0.42;\nconst float innerSelectedRingSize = 0.43;\nconst float outerSelectedRingSize = 0.47;\nconst float shadowSize = 0.51;\n\nfloat getShadowAlpha(float size, float dist) {\n  return (1.0 - smoothstep(size, shadowSize, dist)) * 0.25;\n}\n\nfloat getCircleAlpha(float ringSize, float nodeSize, float dist) {\n  return color.w - smoothstep(ringSize - nodeSize, ringSize, dist);\n}\n\nvoid main() {\n  float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  } else {\n    float nodeSize = 1.0 / varNodeSize;\n    float nodeAlpha = getCircleAlpha(circleSize, nodeSize, dist);\n    float borderAlpha = getCircleAlpha(defaultBorderSize, nodeSize, dist);\n    float ringAlpha = getCircleAlpha(innerSelectedRingSize, nodeSize, dist);\n    vec3 finalColor = color.xyz;\n    float finalAlpha = nodeAlpha;\n\n    if (selected > 0.0) {\n      float shadowAlpha = getShadowAlpha(outerSelectedRingSize, dist);\n      float ringAlpha2 = getCircleAlpha(outerSelectedRingSize, nodeSize, dist);\n\n      if (u_drawDefaultBorder > 0.0) {\n        finalColor = mix(u_nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(u_selectedInnerBorderColor, finalColor, borderAlpha);\n        finalColor = mix(u_selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(u_shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(borderAlpha, ringAlpha2)));\n      } else {\n        finalColor = mix(u_selectedInnerBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(u_selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(u_shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(ringAlpha, ringAlpha2)));\n      }\n    } else if (hovered > 0.0) {\n      if (u_drawDefaultBorder > 0.0) {\n        float shadowAlpha = getShadowAlpha(defaultBorderSize, dist);\n        finalColor = mix(u_nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(u_shadowColor, finalColor, borderAlpha);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, ringAlpha));\n      } else {\n        float shadowAlpha = getShadowAlpha(circleSize, dist);\n        finalColor = mix(u_shadowColor, finalColor, nodeAlpha);\n        finalAlpha = max(shadowAlpha, nodeAlpha);\n      }\n    } else {\n      if (u_drawDefaultBorder > 0.0) {\n        finalColor = mix(u_nodeBorderColor, finalColor, nodeAlpha);\n        finalAlpha = borderAlpha;\n      }\n    }\n\n    bool iconLargeEnough = varNodeSize * circleSize >= u_minIconScreenPx;\n    if (hasIcon > 0.5 && iconLargeEnough) {\n      vec2 uv = (gl_PointCoord - vec2(0.5)) / circleSize + 0.5;\n\n      float inX = step(0.0, uv.x) - step(1.0, uv.x);\n      float inY = step(0.0, uv.y) - step(1.0, uv.y);\n      float isInside = inX * inY;\n\n      vec4 ic = texture(u_icons, vec3(uv, iconLayer));\n      finalColor = mix(finalColor, ic.rgb, ic.a * isInside);\n    }\n\n    fragColor = vec4(finalColor, 1.0) * finalAlpha;\n  }\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/node-vertex-point.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\nuniform lowp vec3 u_nodeBorderColor;\nuniform lowp vec3 u_selectedBorderColor;\nuniform lowp vec3 u_selectedInnerBorderColor;\nuniform lowp vec3 u_shadowColor;\nuniform lowp float u_drawDefaultBorder;\n\nattribute float a_size;\nattribute lowp vec2 a_index;\nattribute lowp vec4 a_color;\nattribute lowp float a_selected;\nattribute lowp float a_hovered;\n\nvarying lowp float window;\nvarying lowp vec4 color;\nvarying lowp float selected;\nvarying lowp float hovered;\nvarying lowp float varNodeSize;\nvarying lowp vec3 nodeBorderColor;\nvarying lowp vec3 selectedBorderColor;\nvarying lowp vec3 selectedInnerBorderColor;\nvarying lowp vec3 shadowColor;\nvarying lowp float drawDefaultBorder;\n\nlowp float MinNodeSize = 5.0;\n\nvoid main(void) {\n  vec4 data = texture2D(u_positions, a_index);\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  lowp float nodeSize = a_size * u_zoom * u_glAdjust;\n  if (nodeSize < MinNodeSize) {\n   gl_PointSize = MinNodeSize;\n   varNodeSize = MinNodeSize;\n  } else {\n    gl_PointSize = nodeSize;\n    varNodeSize = nodeSize;\n  }\n\n  color = a_color;\n  selected = a_selected;\n  hovered = a_hovered;\n  nodeBorderColor = u_nodeBorderColor;\n  selectedBorderColor = u_selectedBorderColor;\n  selectedInnerBorderColor = u_selectedInnerBorderColor;\n  shadowColor = u_shadowColor;\n  drawDefaultBorder = u_drawDefaultBorder;\n}";
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nin float a_size;\nin highp vec2 a_index;\nin lowp vec4 a_color;\nin lowp float a_selected;\nin lowp float a_hovered;\nin lowp float a_iconLayer;\nin lowp float a_hasIcon;\n\nout lowp vec4 color;\nout lowp float selected;\nout lowp float hovered;\nout mediump float varNodeSize;\nout mediump float iconLayer;\nout lowp float hasIcon;\n\nconst float MinNodeSize = 5.0;\n\nvoid main(void) {\n  vec4 data = texture(u_positions, a_index);\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  float nodeSize = max(a_size * u_zoom * u_glAdjust, MinNodeSize);\n  gl_PointSize = nodeSize;\n  varNodeSize = nodeSize;\n\n  color = a_color;\n  selected = a_selected;\n  hovered = a_hovered;\n  iconLayer = a_iconLayer * 255.0;\n  hasIcon = a_hasIcon;\n}";
 export default _default;

package/dist/types/renderers/webglrenderer/rel-fragment-line.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "varying lowp vec4 color;\n\nvoid main(void) {\n  gl_FragColor = vec4(color.xyz, 1.0) * color.w;\n}\n";
+declare const _default: "#version 300 es\nprecision lowp float;\n\nin lowp vec4 color;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  fragColor = vec4(color.xyz, 1.0) * color.w;\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/rel-glsl-utils.d.ts

@@ -0,0 +1 @@
+export declare const arrowShaderUtilsGLSL = "\nconst float CircleSize = 0.40;\nconst float HeadHalfWidthScale = 4.0;\nconst float HeadLengthScale = 2.5;\nconst float MaxHeadHalfWidthRatio = 0.6;\nconst float MaxHeadLengthRatio = 1.0;\n\n// Self-referencing relationships aren't supported in WebGL yet.\nbool relationshipIsSelfLoop(vec2 fromTexel, vec2 toTexel) {\n  return all(equal(fromTexel, toTexel));\n}\n\nvec2 perpendicular(vec2 dir) {\n  return vec2(-dir.y, dir.x);\n}\n\nfloat nodeRadiusFromSize(float size) {\n  return size * u_glAdjust * CircleSize;\n}\n\nfloat relationshipHalfWidth(float width) {\n  return width * u_glAdjust * 0.25;\n}\n\nfloat naturalArrowHeadHalfWidth(float lineHalfWidth) {\n  return lineHalfWidth * HeadHalfWidthScale + u_glAdjust;\n}\n\nfloat naturalArrowHeadLength(float headHalfWidth) {\n  return headHalfWidth * HeadLengthScale;\n}\n\nfloat clampArrowHeadHalfWidth(float lineHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadHalfWidth(lineHalfWidth);\n  float minHalfWidth = lineHalfWidth;\n  float maxHalfWidth = max(minHalfWidth, nodeRadius * MaxHeadHalfWidthRatio);\n  return clamp(natural, minHalfWidth, maxHalfWidth);\n}\n\nfloat clampArrowHeadLength(float headHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadLength(headHalfWidth);\n  float maxLength = nodeRadius * MaxHeadLengthRatio;\n  return min(natural, maxLength);\n}\n\nfloat arrowHeadClearance(float lineHalfWidth, float nodeRadius) {\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, nodeRadius);\n  return clampArrowHeadLength(headHalfWidth, nodeRadius);\n}\n";

package/dist/types/renderers/webglrenderer/rel-vertex-arrow.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_glAdjust;\n\nin vec2 a_from;\nin vec2 a_to;\nin lowp vec4 a_color;\nin float a_width;\nin float a_toSize;\n\nout lowp vec4 color;\n\n\nconst float CircleSize = 0.40;\nconst float HeadHalfWidthScale = 4.0;\nconst float HeadLengthScale = 2.5;\nconst float MaxHeadHalfWidthRatio = 0.6;\nconst float MaxHeadLengthRatio = 1.0;\n\n// Self-referencing relationships aren't supported in WebGL yet.\nbool relationshipIsSelfLoop(vec2 fromTexel, vec2 toTexel) {\n  return all(equal(fromTexel, toTexel));\n}\n\nvec2 perpendicular(vec2 dir) {\n  return vec2(-dir.y, dir.x);\n}\n\nfloat nodeRadiusFromSize(float size) {\n  return size * u_glAdjust * CircleSize;\n}\n\nfloat relationshipHalfWidth(float width) {\n  return width * u_glAdjust * 0.25;\n}\n\nfloat naturalArrowHeadHalfWidth(float lineHalfWidth) {\n  return lineHalfWidth * HeadHalfWidthScale + u_glAdjust;\n}\n\nfloat naturalArrowHeadLength(float headHalfWidth) {\n  return headHalfWidth * HeadLengthScale;\n}\n\nfloat clampArrowHeadHalfWidth(float lineHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadHalfWidth(lineHalfWidth);\n  float minHalfWidth = lineHalfWidth;\n  float maxHalfWidth = max(minHalfWidth, nodeRadius * MaxHeadHalfWidthRatio);\n  return clamp(natural, minHalfWidth, maxHalfWidth);\n}\n\nfloat clampArrowHeadLength(float headHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadLength(headHalfWidth);\n  float maxLength = nodeRadius * MaxHeadLengthRatio;\n  return min(natural, maxLength);\n}\n\nfloat arrowHeadClearance(float lineHalfWidth, float nodeRadius) {\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, nodeRadius);\n  return clampArrowHeadLength(headHalfWidth, nodeRadius);\n}\n\n\nvoid main(void) {\n  vec4 from = texture(u_positions, a_from);\n  vec4 to = texture(u_positions, a_to);\n\n  if (relationshipIsSelfLoop(a_from, a_to)) {\n    color = a_color;\n    gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n    return;\n  }\n\n  vec2 delta = to.xy - from.xy;\n  vec2 dir = normalize(delta);\n  vec2 perp = perpendicular(dir);\n\n  float toRadius = nodeRadiusFromSize(a_toSize);\n  float lineHalfWidth = relationshipHalfWidth(a_width);\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, toRadius);\n  float headLength = clampArrowHeadLength(headHalfWidth, toRadius);\n\n  vec2 tip = to.xy - dir * toRadius;\n  vec2 baseCenter = tip - dir * headLength;\n\n  int corner = gl_VertexID % 3;\n  float isTip = float(corner == 0);\n  float perpSign = float(corner == 1) - float(corner == 2);\n  vec2 basePos = mix(baseCenter, tip, isTip);\n  vec2 vertexPosition = basePos + perp * (headHalfWidth * perpSign);\n\n  color = a_color;\n  gl_Position = u_projection * vec4(vertexPosition, 0.0, 1.0);\n}\n";
+export default _default;

package/dist/types/renderers/webglrenderer/rel-vertex-line.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_glAdjust;\n\nattribute vec2 a_from;\nattribute vec2 a_to;\nattribute lowp vec4 a_color;\nattribute lowp float a_triside;\nattribute float a_width;\n\nvarying lowp vec4 color;\n\nvoid main(void) {\n  vec4 from = texture2D(u_positions, a_from);\n  vec4 to = texture2D(u_positions, a_to);\n  vec2 direction = normalize(to.xy - from.xy);\n  direction = vec2(-direction.y, direction.x);\n\n  float width = a_width * u_glAdjust * 0.5;\n\n  if (a_triside == 0.0) {\n    from.y += (width / 2.0) * direction.y;\n    from.x += (width / 2.0) * direction.x;\n  } else {\n    from.y -= (width / 2.0) * direction.y;\n    from.x -= (width / 2.0) * direction.x;\n  }\n\n  color = a_color;\n  gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n}\n";
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_glAdjust;\n\nin vec2 a_from;\nin vec2 a_to;\nin lowp vec4 a_color;\nin lowp float a_triside;\nin lowp float a_isTarget;\nin float a_endpointSize;\nin float a_otherEndpointSize;\nin float a_width;\n\nout lowp vec4 color;\n\n\nconst float CircleSize = 0.40;\nconst float HeadHalfWidthScale = 4.0;\nconst float HeadLengthScale = 2.5;\nconst float MaxHeadHalfWidthRatio = 0.6;\nconst float MaxHeadLengthRatio = 1.0;\n\n// Self-referencing relationships aren't supported in WebGL yet.\nbool relationshipIsSelfLoop(vec2 fromTexel, vec2 toTexel) {\n  return all(equal(fromTexel, toTexel));\n}\n\nvec2 perpendicular(vec2 dir) {\n  return vec2(-dir.y, dir.x);\n}\n\nfloat nodeRadiusFromSize(float size) {\n  return size * u_glAdjust * CircleSize;\n}\n\nfloat relationshipHalfWidth(float width) {\n  return width * u_glAdjust * 0.25;\n}\n\nfloat naturalArrowHeadHalfWidth(float lineHalfWidth) {\n  return lineHalfWidth * HeadHalfWidthScale + u_glAdjust;\n}\n\nfloat naturalArrowHeadLength(float headHalfWidth) {\n  return headHalfWidth * HeadLengthScale;\n}\n\nfloat clampArrowHeadHalfWidth(float lineHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadHalfWidth(lineHalfWidth);\n  float minHalfWidth = lineHalfWidth;\n  float maxHalfWidth = max(minHalfWidth, nodeRadius * MaxHeadHalfWidthRatio);\n  return clamp(natural, minHalfWidth, maxHalfWidth);\n}\n\nfloat clampArrowHeadLength(float headHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadLength(headHalfWidth);\n  float maxLength = nodeRadius * MaxHeadLengthRatio;\n  return min(natural, maxLength);\n}\n\nfloat arrowHeadClearance(float lineHalfWidth, float nodeRadius) {\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, nodeRadius);\n  return clampArrowHeadLength(headHalfWidth, nodeRadius);\n}\n\n\nvoid main(void) {\n  vec4 from = texture(u_positions, a_from);\n  vec4 to = texture(u_positions, a_to);\n\n  if (relationshipIsSelfLoop(a_from, a_to)) {\n    color = a_color;\n    gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n    return;\n  }\n\n  vec2 delta = from.xy - to.xy;\n  float halfWidth = relationshipHalfWidth(a_width);\n  float ownRadius = nodeRadiusFromSize(a_endpointSize);\n  float otherRadius = nodeRadiusFromSize(a_otherEndpointSize);\n  float toRadius = mix(otherRadius, ownRadius, a_isTarget);\n  float arrowClearance = arrowHeadClearance(halfWidth, toRadius);\n  float endpointClearance = ownRadius + a_isTarget * arrowClearance;\n\n  vec2 along = normalize(delta);\n  from.xy -= along * endpointClearance;\n\n  float sideSign = 1.0 - 2.0 * a_triside;\n  from.xy += sideSign * halfWidth * perpendicular(along);\n\n  color = a_color;\n  gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/viewport-box-fragment.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "\nvarying lowp vec4 minimapViewportBoxColor;\n\nvoid main(void) {\n gl_FragColor = minimapViewportBoxColor;\n}\n";
+declare const _default: "#version 300 es\nprecision lowp float;\n\nuniform lowp vec4 u_minimapViewportBoxColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  fragColor = u_minimapViewportBoxColor;\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/viewport-box-vertex.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "\nattribute vec2 coordinates;\nuniform mat4 u_projection;\nuniform lowp vec4 u_minimapViewportBoxColor;\n\nvarying lowp vec4 minimapViewportBoxColor;\n\nvoid main(void) {\n  gl_Position = u_projection * vec4(coordinates, 0.0, 1.0);\n  minimapViewportBoxColor = u_minimapViewportBoxColor;\n}\n";
+declare const _default: "#version 300 es\nin vec2 coordinates;\nuniform mat4 u_projection;\n\nvoid main(void) {\n  gl_Position = u_projection * vec4(coordinates, 0.0, 1.0);\n}\n";
 export default _default;

package/dist/types/types/graph-element.d.ts

@@ -1,4 +1,5 @@
 import type { StyledCaption } from '../renderers/domrenderer/shared/types';
+import type { Point } from '../utils/geometry';
 /**
  * The base type for graph elements.
  * @private
@@ -97,6 +98,13 @@ interface Node extends GraphElement {
      */
     html?: HTMLElement;
 }
+/**
+ * A node returned by {@link NVL.getNodes} with layout coordinates and screen position.
+ * `x` and `y` are canvas/layout space; `clientPosition` is relative to the canvas element.
+ */
+type NodeWithClientPosition = Node & Point & {
+    clientPosition: Point;
+};
 /**
  * A node with only a subset of its properties.
  */
@@ -132,4 +140,4 @@ type PartialRelationship = Partial<Relationship> & {
     /** The id of the relationship. */
     id: string;
 };
-export type { Node, Relationship, PartialNode, PartialRelationship };
+export type { Node, NodeWithClientPosition, Relationship, PartialNode, PartialRelationship };

package/dist/types/types/nvl-window-functions.d.ts

@@ -1,6 +1,6 @@
-import type { Node, Relationship } from './graph-element';
+import type { Node, NodeWithClientPosition, Relationship } from './graph-element';
 export interface NvlWindow {
-    __Nvl_dumpNodes: (instanceId?: string) => Node[];
+    __Nvl_dumpNodes: (instanceId?: string) => NodeWithClientPosition[];
     __Nvl_dumpRelationships: (instanceId?: string) => Relationship[];
     __Nvl_getNodesOnScreen: (instanceId?: string) => {
         nodes: Node[];

package/dist/types/utils/canvasManagement.d.ts

@@ -13,7 +13,7 @@ export declare const createCanvasForScreenshot: (fullWidth: number, fullHeight:
 export declare const createCanvasForRenderer: (parent?: HTMLElement, onContextLostCallback?: (e: WebGLContextEvent) => void) => HTMLCanvasElement;
 export declare const removeCanvas: (canvas: HTMLCanvasElement) => void;
 export declare const getCanvas2DContext: (canvas: HTMLCanvasElement) => CanvasRenderingContext2D;
-export declare const getWebGLContext: (canvas: HTMLCanvasElement) => WebGLRenderingContext;
+export declare const getWebGLContext: (canvas: HTMLCanvasElement) => WebGL2RenderingContext | null;
 export declare const removeWebGLContext: (webGLCtx: WebGLRenderingContext) => void;
 export declare const checkWebGLAvailability: (canvas?: HTMLCanvasElement) => boolean;
 /**

package/dist/types/utils/clusterGeometry.d.ts

@@ -0,0 +1,14 @@
+import { type Point } from './geometry';
+/** Extra world-space padding around each member disk before taking the cluster hull. */
+export declare const ClusterHullPadding = 14;
+/** Circumference samples per member disk before taking the convex hull. */
+export declare const DiskSampleCount = 8;
+export type ClusterMemberDisk = Point & {
+    radius: number;
+};
+/**
+ * Fits a convex hull around the given disks by sampling each member circumference.
+ * @param members - The cluster member disks to fit the hull around.
+ * @returns The fitted hull, or null if fewer than two members have a usable position/radius.
+ */
+export declare const fitClusterHull: (members: ClusterMemberDisk[]) => Point[] | null;

package/dist/types/utils/clusterGeometry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/clusterHitRegions.d.ts

@@ -0,0 +1,42 @@
+import { type CoarsenedGraph, type Sun } from '../layouts/forcedirectedlayout/clustering/types';
+import type { Cluster, ClusterId } from '../modules/state/types';
+import type { Node } from '../types/graph-element';
+import { type ClusterMemberDisk } from './clusterGeometry';
+import { type Point } from './geometry';
+/**
+ * A fitted cluster hull region used for decoration and hit-testing.
+ */
+export type ClusterHitRegion = Cluster & {
+    /** Convex hull used for picking / decoration. */
+    hull: Point[];
+    /** Layout sun original id (e.g. `synth-sun:${id}`). */
+    sunOriginalId: string;
+};
+export type MultiMemberCluster = {
+    sun: Sun;
+    nodeIds: string[];
+};
+/**
+ * Returns each multi-member first-level sun system in a coarsening hierarchy.
+ * @param firstSubGraphLevel - `subGraphs[1]` from the current layout coarsening hierarchy.
+ * @returns Suns paired with their original member node ids.
+ */
+export declare const getMultiMemberClusters: (firstSubGraphLevel: CoarsenedGraph) => MultiMemberCluster[];
+/**
+ * Collects member disks with usable positions for hull fitting.
+ * @param nodeIds - Member node ids.
+ * @param idToPosition - Node id to position map.
+ * @param idToItem - Node id to graph node map.
+ * @returns Member disks for {@link fitClusterHull}.
+ */
+export declare const collectMemberDisks: (nodeIds: string[], idToPosition: Readonly<Record<string, Point>>, idToItem: Record<string, Node>) => ClusterMemberDisk[];
+/**
+ * Builds hit regions for {@link ClusteringOptions.clusterBy} multi-member clusters.
+ * Structural {@link SolarMerger} suns are skipped, as they have no entry in `clusterIdsBySun`.
+ * @param subGraphs - Layout coarsening hierarchy.
+ * @param idToPosition - Node id to position map.
+ * @param idToItem - Node id to graph node map.
+ * @param clusterIdsBySun - Cluster id per synthetic cluster sun, keyed by sun `originalId`.
+ * @returns Fitted cluster hit regions.
+ */
+export declare const buildClusterByHitRegions: (subGraphs: CoarsenedGraph[], idToPosition: Readonly<Record<string, Point>>, idToItem: Record<string, Node>, clusterIdsBySun: ReadonlyMap<string, ClusterId>) => ClusterHitRegion[];

package/dist/types/utils/clusterHitRegions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/constants.d.ts

@@ -5,6 +5,12 @@ export declare const MinRelLength = 100;
 export declare const Gravity = 25;
 export declare const SimulationStopVelocity = 0.25;
 export declare const MappingEnd = 999999;
+export declare const LayoutStepIntervalMs = 13;
+export declare const MaxLayoutStepsPerFrame = 20;
+export declare const DefaultMaxFps = 30;
+export declare const DefaultMinFps = 3;
+export declare const MinAllowedFps = 1;
+export declare const MaxAllowedFps = 120;
 export declare const ActiveAnimDuration = 1000;
 export declare const DefaultNodeSize = 25;
 export declare const DefaultNodeColor = "#FFDF81";

package/dist/types/utils/geometry.d.ts

@@ -8,11 +8,11 @@ export interface Point {
     /** The y coordinate of the point. */
     y: number;
 }
-export declare const isPointDefined: (point: Point | Node) => boolean;
 /**
  * Returns true when value is a finite number (not NaN or Infinity).
  */
 export declare const isValidFiniteNumber: (value: unknown) => value is number;
+export declare const isPointDefined: (point: Point | Node | null | undefined) => point is Point;
 /**
  * This function checks if the coordinates are defined.
  * @param from - The {@link Node} the edge starts from.
@@ -126,3 +126,46 @@ export declare const getIntersection: (p0: Point, p1: Point, p2: Point, p3: Poin
  * @returns The distance between the point and the curve.
  */
 export declare const getDistanceToQuadratic: (fromCoordinates: Point, toCoordinates: Point, control: Point, point: Point) => number;
+/**
+ * Converts a polar coordinate (radius + angle around a centre) to a cartesian point.
+ * @param centre - The centre of the circle.
+ * @param radius - The radius of the circle.
+ * @param angle - The angle around the circle, in radians.
+ * @returns The point at that angle and radius from the centre.
+ */
+export declare const pointOnCircle: (centre: Point, radius: number, angle: number) => Point;
+/**
+ * Returns the point halfway between two points.
+ * @param a - The first point.
+ * @param b - The second point.
+ * @returns The midpoint of the segment from a to b.
+ */
+export declare const getMidPoint: (a: Point, b: Point) => Point;
+/**
+ * Places child points evenly spaced around a circle centred on a point.
+ * @param centre - The centre of the circle.
+ * @param radius - The radius of the circle.
+ * @param noOfChildren - The number of points to place around the circle.
+ * @returns The evenly spaced points.
+ */
+export declare const calculateCirclePositions: (centre: Point, radius: number, noOfChildren: number) => Point[];
+/**
+ * Andrew's monotone-chain convex hull.
+ * @param points - The points to get the convex hull of.
+ * @returns The convex hull of the points.
+ */
+export declare const getConvexHull: (points: Point[]) => Point[];
+/**
+ * Returns true when the point lies inside or on the boundary of a convex polygon.
+ * Works for both clockwise and counter-clockwise vertex order.
+ * @param point - The point to test.
+ * @param polygon - Convex polygon vertices in order around the boundary.
+ * @returns True when the point is inside or on the polygon.
+ */
+export declare const isPointInConvexPolygon: (point: Point, polygon: Point[]) => boolean;
+/**
+ * Absolute area of a simple polygon via the shoelace formula.
+ * @param polygon - Polygon vertices in order around the boundary.
+ * @returns The absolute area of the polygon.
+ */
+export declare const getPolygonArea: (polygon: Point[]) => number;

package/dist/types/utils/hittest.d.ts

@@ -1,5 +1,6 @@
-import type { NvlState } from '../modules/state/types';
+import type { Cluster, NvlState } from '../modules/state/types';
 import type { Node, Relationship } from '../types/graph-element';
+import type { ClusterHitRegion } from './clusterHitRegions';
 import type { Point } from './geometry';
 /**
  * A node that has been hit by a pointer event
@@ -34,7 +35,18 @@ export interface HitTargetRelationship {
     distance: number;
 }
 /**
- * A collection of nodes and relationships that have been hit by a pointer event
+ * A {@link ClusteringOptions.clusterBy} cluster hull that has been hit by a pointer event
+ */
+export interface HitTargetCluster {
+    /** The cluster that was hit */
+    data: Cluster;
+    /** The coordinates of the pointer event */
+    pointerCoordinates: Point;
+    /** The convex hull used for the hit test */
+    hull: Point[];
+}
+/**
+ * A collection of nodes, relationships and clusters that have been hit by a pointer event
  * Part of the result of a {@link NVL}.{@link NVL.getHits} call
  */
 export type HitTargets = {
@@ -42,15 +54,29 @@ export type HitTargets = {
     nodes: HitTargetNode[];
     /** The relationships that have been hit by the pointer event. */
     relationships: HitTargetRelationship[];
+    /** The cluster hulls that have been hit by the pointer event. */
+    clusters: HitTargetCluster[];
 };
-export declare const hitTest: (x: number, y: number, state: NvlState, targets?: string[], options?: {
+export type HitTestTarget = 'node' | 'relationship' | 'cluster';
+/**
+ * Finds all cluster hulls that contain the given point.
+ * Overlapping hulls are returned smallest-first (most specific).
+ * @param x - X coordinate.
+ * @param y - Y coordinate.
+ * @param regions - Fitted cluster hit regions.
+ * @returns Cluster hits sorted by ascending hull area.
+ */
+export declare const hitClusterTest: (x: number, y: number, regions: ClusterHitRegion[]) => HitTargetCluster[];
+export declare const hitTest: (x: number, y: number, state: NvlState, targets?: HitTestTarget[], options?: {
     hitNodeMarginWidth?: number;
+    clusterRegions?: ClusterHitRegion[];
 }) => HitTargets;
 export declare const hitTestCanvas: (x: number, y: number, parentHandler: {
     getCanvasNodesAt: (c: Point, m: number) => HitTargetNode[];
     getCanvasRelsAt: (c: Point) => HitTargetRelationship[];
-}, targets?: string[], options?: {
+}, targets?: readonly HitTestTarget[], options?: {
     hitNodeMarginWidth?: number;
+    clusterRegions?: ClusterHitRegion[];
 }) => HitTargets;
 export declare const hitTestBox: (x1: number, y1: number, x2: number, y2: number, state: NvlState, targets?: string[]) => {
     nodes: Node[];

package/dist/types/utils/jsDriverResultTransformer.d.ts

@@ -16,17 +16,19 @@ export declare const recordCollector: (graphElements: NestedGraphElements[]) =>
  * @example
  *
  * ```ts
- * import neo4j from "neo4j-driver";
- * import { nvlResultTransformer, NVL } from "@neo4j-nvl/base";
+ * import * as neo4j from 'neo4j-driver'
+ * import { nvlResultTransformer, NVL } from '@neo4j-nvl/base'
  *
- * const driver = neo4j.driver("{uri}", neo4j.auth.basic("{user}", "{password}"));
- * const nvlGraph = await driver.executeQuery(
- *   "MATCH (a)-[r]-(b) RETURN a,r,b LIMIT 25",
- *   {},
- *   { resultTransformer: nvlResultTransformer }
- * );
+ * const run = async () => {
+ *   const driver = neo4j.driver('{uri}', neo4j.auth.basic('{user}', '{password}'))
+ *   const nvlGraph = await driver.executeQuery(
+ *     'MATCH (a)-[r]-(b) RETURN a,r,b LIMIT 25',
+ *     {},
+ *     { resultTransformer: nvlResultTransformer }
+ *   )
  *
- * const nvl = new NVL(document.getElementById('viz'), nvlGraph.nodes, nvlGraph.relationships);
+ *   const nvl = new NVL(document.getElementById('viz'), nvlGraph.nodes, nvlGraph.relationships)
+ * }
  * ```
  *
  * @see {@link https://neo4j.com/docs/api/javascript-driver/current/class/lib6/result-transformers.js~ResultTransformers.html|ResultTransformers on Neo4j JS Driver API Docs}

package/dist/types/utils/layoutSeeding.d.ts

@@ -0,0 +1,7 @@
+import type { Point } from './geometry';
+export type SeedingMethod = 'box' | 'circle';
+export declare const getCircleSeedRadius: (nodeCount: number, seedSpacing: number) => number;
+export declare const getBoxStartSize: (nodeCount: number) => number;
+export declare const getCirclePositionsForNodeCount: (nodeCount: number, center: Point, radius: number) => Point[];
+export declare const getBoxPositionsForNodeCount: (nodeCount: number, center: Point) => Point[];
+export declare const getSeedPositions: (nodeCount: number, seedingMethod: SeedingMethod, center?: Point) => Point[];

package/dist/types/utils/layoutSeeding.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/webWorkerUtils.d.ts

@@ -1,3 +1,3 @@
-type Layouts = 'CoseBilkentLayout' | 'HierarchicalLayout';
+type Layouts = 'HierarchicalLayout';
 export declare const initializeWorker: (workerName: Layouts, workersDisabled?: boolean) => SharedWorker;
 export {};

package/dist/types/utils/zoomFunctions.d.ts

@@ -1,5 +1,11 @@
 import type { Node } from '../index';
 import type { Point } from './geometry';
+/**
+ * Gets padding for fitting nodes, which is twice the largest node radius.
+ * @param maxNodeRadius - The largest node radius.
+ * @returns The padding for fitting nodes.
+ */
+declare const getFitNodesPadding: (maxNodeRadius?: number) => number;
 declare const getExtremeLimits: (nodePositions: Point[]) => Point[];
 declare const getMaxDistance: (extremeLimits?: Point[]) => number;
 /**
@@ -40,7 +46,8 @@ declare const createZoomTarget: (zoomX: number, zoomY: number, minZoom?: number,
  * @param nodePositions - The node positions.
  * @param containerWidth - The width of the container NVL is displayed in.
  * @param containerHeight - The height of the container NVL is displayed in.
- * @param maxNodeRadius - The maximum node radius, which is added as margin to the scene (defaults to `50`).
+ * @param maxNodeRadius - The maximum node radius, which is added as margin to the scene
+ * (defaults to 2 * {@link DefaultNodeSize}).
  * @returns The zoom and pan targets.
  */
 declare const getZoomTargetForNodePositions: (nodePositions: Point[], containerWidth: number, containerHeight: number, maxNodeRadius?: number) => {
@@ -55,4 +62,4 @@ declare const getFlexibleZoomLimit: (nodePositions: Point[], rect: HTMLCanvasEle
 declare const getNewZoomWithinLimits: (newZoom: number, oldZoom: number, minZoom: number, maxZoom: number) => number;
 declare const isZoomOutAtLimit: (newZoom: number, oldZoom: number, zoomOutLimit: number) => boolean;
 declare const getDynamicZoom: (nodePositions: Point[] & Node[], minZoom: number, maxZoom: number, rect: HTMLCanvasElement, newZoom: number, currentZoom: number) => number;
-export { getFlexibleZoomLimit, getZoomTargetForNodePositions, isZoomOutAtLimit, getNewZoomWithinLimits, getExtremeLimits, getMaxDistance, getPositionBoundaries, getZoomLevel, createZoomTarget, getDynamicZoom };
+export { getFitNodesPadding, getFlexibleZoomLimit, getZoomTargetForNodePositions, isZoomOutAtLimit, getNewZoomWithinLimits, getExtremeLimits, getMaxDistance, getPositionBoundaries, getZoomLevel, createZoomTarget, getDynamicZoom };