@neo4j-nvl/base 0.3.1 → 0.3.2

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

@@ -1,53 +1,64 @@
-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";
+import type { Node, Relationship } from '../types/graph-element';
+import '../types/nvl-window-functions';
+import type { Point } from '../utils/geometry';
+import type { ExternalCallbacks } from './ExternalCallbackHandler';
+import type { Layout, LayoutOptions, NvlOptions, NvlState, ZoomOptions } from './state';
+type SaveToFileOptions = {
+    filename?: string;
+    backgroundColor?: string;
+};
+export declare const EVENT_ERROR = "onError";
+export declare const EVENT_LAYOUT_DONE = "onLayoutDone";
+export declare const EVENT_LAYOUT_STEP = "onLayoutStep";
+export declare const EVENT_LAYOUT_COMPUTING = "onLayoutComputing";
+export declare 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;
+    private destroyed;
+    private readonly state;
+    private readonly callbacks;
+    private readonly instanceId;
+    private readonly glController;
+    private readonly webGLContext;
+    private readonly webGLMinimapContext;
+    private readonly htmlOverlay;
+    private hasResized;
+    private readonly hierarchicalLayout;
+    private readonly gridLayout;
+    private readonly freeLayout;
+    private readonly d3ForceLayout;
+    private readonly forceLayout;
+    private readonly canvasRenderer;
+    private readonly glCanvas;
+    private canvasRect;
+    private readonly glMinimapCanvas;
+    private readonly c2dCanvas;
+    private isInRenderSwitchAnimation;
+    private justSwitchedRenderer;
+    private justSwitchedLayout;
+    private layoutUpdating;
+    private layoutComputing;
+    private isRenderingDisabled;
+    private readonly setRenderSwitchAnimation;
+    private readonly stateDisposers;
+    private readonly zoomTransitionHandler;
+    private currentLayout;
+    private readonly layoutTimeLimit;
+    private pixelRatio;
+    private readonly removeResizeListener;
+    private readonly removeMinimapResizeListener;
+    private pendingZoomOperation;
+    private layoutRunner;
+    private animationRequestId;
+    private layoutDoneCallback;
+    private layoutComputingCallback;
+    private currentLayoutType;
+    constructor(state: NvlState, options: NvlOptions);
+    private onWebGLContextLost;
+    private updateMinimapZoom;
+    private startMainLoop;
     updateHtmlOverlay(): void;
-    dumpNodes(): any[];
-    dumpRelationships(): any;
+    dumpNodes(): Node[];
+    dumpRelationships(): Relationship[];
     /**
      * Map a relative Canvas space to the DOM position
      * @param {number} canvasX X position in the canvas space
@@ -62,58 +73,43 @@ export default class NvlController {
      * @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;
+    mapRelativePositionToCanvasSpace(clientX: number, clientY: number): {
+        x: number;
+        y: number;
     };
-    getNodePositions(): any[];
-    setNodePositions(data: any, updateLayout?: boolean): void;
+    getNodePositions(): (Node & Point)[];
+    setNodePositions(data: Node[], updateLayout?: boolean): void;
     isLayoutMoving(): boolean;
     getNodesOnScreen(): {
-        nodes: import("..").Node[];
-        rels: import("..").Relationship[];
+        nodes: Node[];
+        rels: 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;
+    registerDoneCallback(cb: NvlController['layoutDoneCallback']): void;
+    registerComputingCallback(cb: NvlController['layoutComputingCallback']): void;
+    getPosition(nodeId: string): Node;
+    getScale(): number;
     getPan(): {
-        x: any;
-        y: any;
+        x: number;
+        y: number;
     };
-    setZoomLevel(_newLevel: any): void;
-    setPanCoordinates(panX: any, panY: any): void;
-    setZoomAndPan(zoom: any, panX: any, panY: any): void;
-    fit(nodeIds: any, zoomOptions: any): void;
+    setZoomLevel(_newLevel: number): void;
+    setPanCoordinates(panX: number, panY: number): void;
+    setZoomAndPan(zoom: number, panX: number, panY: number): void;
+    fit(nodeIds: string[], zoomOptions: ZoomOptions): void;
     resetZoom(): void;
-    setRenderer(renderer: any): void;
-    on(name: any, callback: any): void;
+    setRenderer(renderer: string): void;
+    on(name: keyof ExternalCallbacks, callback: (args: unknown) => void): void;
+    isDestroyed(): boolean;
     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>;
+    getCanvasRelsAt(point: Point): import("../utils/hittest").HitTargetRelationship[];
+    getCanvasNodesAt(point: Point, hitNodeMarginWidth?: number): import("../utils/hittest").HitTargetNode[];
+    private getLayout;
+    setLayout(layoutType: Layout): void;
+    setLayoutOptions(options: LayoutOptions): void;
+    createDownloadLink(filename: string, canvas: HTMLCanvasElement): HTMLAnchorElement;
+    saveToFile(options: SaveToFileOptions): void;
+    prepareLargeFileForDownload(options: SaveToFileOptions): Promise<unknown>;
+    saveFullGraphToLargeFile(options: SaveToFileOptions): 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';
+export {};

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

@@ -1,18 +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;
+    private readonly shaderProgram;
+    private readonly gl;
+    private curTexture;
+    private attributeInfo;
+    private uniformInfo;
+    constructor(gl: WebGLRenderingContext, vsSource: string, fsSource: string, defines?: {});
+    setUniform(name: string, value: any): void;
+    setAttributePointer(name: string, size: number, start: number, stride: number): void;
+    setAttributePointerFloat(name: string, size: number, start: number, stride: number): void;
+    setAttributePointerUShort(name: string | number, size: number, start: number, stride: number): void;
+    setAttributePointerByteNorm(name: string, size: number, start: number, stride: number): void;
+    setAttributePointerByte(name: string, size: number, start: number, stride: number): void;
     use(): void;
     remove(): void;
+    private scanAttributes;
+    private scanUniforms;
 }

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

@@ -13,7 +13,7 @@ export default class ZoomTransitionHandler {
     private readonly stateDisposers;
     constructor({ state, getNodePositions, canvas, defaultZoomLevel }: {
         state: NvlState;
-        getNodePositions: () => Node[];
+        getNodePositions: (data: Node[]) => Node[];
         canvas: HTMLCanvasElement;
         defaultZoomLevel: number;
     });

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

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

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

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

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

@@ -1,5 +1,8 @@
-export function setLogLevel(level: any): void;
-export function setupLogging(logger: any, logging: any): void;
+import type { LogLevelDesc, Logger } from 'loglevel';
+declare const nvlLog: Logger;
+export declare const setLogLevel: (level: LogLevelDesc) => void;
+export declare const setupLogging: (logger: Logger, logging: {
+    level: LogLevelDesc;
+    logger?: (methodName: string, args: unknown) => void;
+}) => void;
 export { nvlLog as log };
-declare const nvlLog: loglevel.Logger;
-import loglevel from 'loglevel';

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

@@ -1,26 +1,29 @@
+import type { LogLevelDesc } from 'loglevel';
 import type { WaypointPath } from '../renderers/canvasrenderer/types';
 import type { ExternalCallbacks } from './ExternalCallbackHandler';
 import type { NodeDataSet, RelationshipDataSet } from './dataset';
 type RingStyle = {
-    widthFactor: number;
+    width?: number;
+    widthFactor?: number;
     color: string;
 };
-type ShadowStyle = {
+export type ShadowStyle = {
     width: number;
     opacity: number;
     color: string;
 };
-type BorderStyle = {
+export type BorderStyle = {
     rings?: RingStyle[];
     shadow?: ShadowStyle;
 };
 /**
  * @internal
  */
-export type NodeBorderStyles = {
-    selected?: BorderStyle;
-    default?: BorderStyle;
+export type BorderStyles = {
+    selected: BorderStyle;
+    default: BorderStyle;
 };
+export declare const RelationshipBorderStyles: BorderStyles;
 /** The default zoom level in a graph when not specified otherwise. */
 export declare const DefaultZoomLevel = 0.75;
 /**
@@ -38,7 +41,11 @@ export interface ForceDirectedOptions {
     /**
      * @internal
      */
-    isCytoscapeEnabled: boolean;
+    enableCytoscape?: boolean;
+    /**
+     * @internal
+     */
+    enableVerlet?: boolean;
     /**
      * @internal
      */
@@ -53,6 +60,7 @@ export interface HierarchicalOptions {
     /** The packing method to be used */
     packing?: 'bin' | 'stack';
 }
+export declare const isHierarchicalLayoutOptions: (options: LayoutOptions) => options is HierarchicalOptions;
 /**
  * The name of the force directed layout
  */
@@ -138,7 +146,13 @@ export interface NvlOptions {
      * @note will be ignored when {@link renderer} is set
      */
     useWebGL?: boolean;
-    /** What renderer to use */
+    /**
+     * What renderer to use
+     * Possible values are 'webgl' or 'canvas'
+     * @defaultValue 'webgl'
+     * @note WebGL renderer uses GPU and has better performance.
+     * Captions and arrowheads are only displayed when using the canvas renderer.
+     */
     renderer?: Renderer;
     /**
      * @internal
@@ -150,7 +164,7 @@ export interface NvlOptions {
      * Specify the log level.
      */
     logging?: {
-        level?: any;
+        level: LogLevelDesc;
     };
     /**
      * @internal
@@ -160,7 +174,18 @@ export interface NvlOptions {
     /** The color to use for the default border of nodes */
     nodeDefaultBorderColor?: string;
     /** The color to use for the selected border of nodes */
-    nodeSelectedBorderColor?: string;
+    selectedBorderColor?: string;
+    /**
+     * @internal
+     * @experimental
+     * Defines a time limit for how long layout iterations may run
+     */
+    layoutTimeLimit?: number;
+    /**
+     * Disables tracking of library usage
+     * @defaultValue false
+     */
+    disableTelemetry?: boolean;
 }
 /** Options that influence how fit-to-zoom should behave */
 export type ZoomOptions = {
@@ -188,6 +213,7 @@ export interface NvlState {
     webGLVisible: boolean;
     renderer: Renderer;
     disableWebGL: boolean;
+    disableTelemetry: boolean;
     fitMovement: number;
     layout: Layout;
     layoutOptions: LayoutOptions;
@@ -220,7 +246,8 @@ export interface NvlState {
     updateMinimapZoomToFit: Function;
     autorun: Function;
     reaction: Function;
-    nodeBorderStyles: NodeBorderStyles;
+    nodeBorderStyles: BorderStyles;
+    relationshipBorderStyles: BorderStyles;
 }
 /**
  * Create a new NVL state

package/dist/types/modules/state.test.d.ts

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

package/dist/types/renderers/canvasrenderer/Animation.test.d.ts

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

package/dist/types/renderers/canvasrenderer/CanvasRenderer.test.d.ts

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

package/dist/types/renderers/canvasrenderer/ImageCache.d.ts

@@ -1,11 +1,11 @@
-import type { Cache, CacheInfo, CacheItem } from './types';
+import type { Cache } from './types';
 declare class ImageCache {
     cache: Cache;
     constructor();
-    getOrCreateEntry(src: string): CacheItem;
-    invertCanvas(ctx: CanvasRenderingContext2D): void;
-    loadImage(src: string): CacheInfo;
-    drawIfNeeded(info: CacheInfo, inverted: boolean): void;
-    getImage(src: string, inverted: boolean): HTMLCanvasElement;
+    getImage(src: string, inverted?: boolean): HTMLCanvasElement;
+    private getOrCreateEntry;
+    private invertCanvas;
+    private loadImage;
+    private drawIfNeeded;
 }
 export default ImageCache;

package/dist/types/renderers/canvasrenderer/ImageCache.test.d.ts

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

package/dist/types/renderers/canvasrenderer/arrows/ArrowBundle.test.d.ts

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

package/dist/types/renderers/canvasrenderer/arrows/ArrowBundler.test.d.ts

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

package/dist/types/renderers/canvasrenderer/arrows/arrows.d.ts

@@ -1,5 +1,7 @@
+import type { BorderStyle } from '../../../modules/state';
 import type { Node, Relationship } from '../../../types/graph-element';
 import type { Point } from '../../../utils/geometry';
+import type ImageCache from '../ImageCache';
 import type ArrowBundle from './ArrowBundle';
 /**
  * This function calculates the difference in radius between two nodes.
@@ -33,9 +35,9 @@ export declare const getPointsForStraight: (rel: Relationship, bundle: ArrowBund
  * @param {boolean} flip - whether to flip the label
  */
 export declare const drawLabel: (ctx: CanvasRenderingContext2D, point: Point, angle: number, maxWidth: number, rel: Relationship, bundle: ArrowBundle, flip?: boolean) => void;
-export declare const renderWaypointArrow: (ctx: CanvasRenderingContext2D, rel: Relationship, from: Node, to: Node, bundle: ArrowBundle, showLabel: boolean, drawCurves: boolean) => void;
-export declare const renderSelfArrow: (ctx: CanvasRenderingContext2D, rel: Relationship, node: Node, bundle: ArrowBundle, showLabel: boolean) => void;
-export declare const renderArrow: (ctx: CanvasRenderingContext2D, rel: Relationship, fromNode: Node, toNode: Node, bundle: ArrowBundle, showLabel: boolean, drawCurves?: boolean) => void;
+export declare const renderWaypointArrow: (ctx: CanvasRenderingContext2D, rel: Relationship, from: Node, to: Node, bundle: ArrowBundle, imageCache: ImageCache, showLabel: boolean, drawCurves: boolean, selectedBorderStyle: BorderStyle) => void;
+export declare const renderSelfArrow: (ctx: CanvasRenderingContext2D, rel: Relationship, node: Node, bundle: ArrowBundle, imageCache: ImageCache, showLabel: boolean, selectedBorderStyle: BorderStyle) => void;
+export declare const renderArrow: (ctx: CanvasRenderingContext2D, rel: Relationship, fromNode: Node, toNode: Node, bundle: ArrowBundle, imageCache: ImageCache, showLabel: boolean, selectedBorderStyle: BorderStyle, drawCurves?: boolean) => void;
 export declare const distanceToEdge: (pos: Point, rel: Relationship, fromNode: Node, toNode: Node, bundle: ArrowBundle, showLabel: boolean, drawCurves?: boolean) => number;
 /**
  * Returns the bounding box of the arrow.

package/dist/types/renderers/canvasrenderer/arrows/arrows.test.d.ts

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

package/dist/types/renderers/canvasrenderer/arrows/constants.d.ts

@@ -28,19 +28,6 @@ export declare const SelfRefHeight = 35;
 export declare const SelfRefLabelMaxWidth = 40;
 /** Width increase when a relationship is selected. */
 export declare const SelectedWidthFactor = 1.5;
-/** The width of the outline of a selected relationship. */
-export declare const SelectedOutlineWidth = 2;
-/** The color of the first outline of a selected relationship. */
-export declare const SelectedOutlineColor1 = "white";
-/** The color of the second outline of a selected relationship. */
-export declare const SelectedOutlineColor2 = "#45bff8";
-/** The shadow properties of a selected relationship. */
-export declare const SelectedShadow: {
-    color: string;
-    size: number;
-    x: number;
-    y: number;
-};
 /** The style properties of a disabled relationship. */
 export declare const Disabled: {
     color: string;

package/dist/types/renderers/canvasrenderer/nodes/nodes.d.ts

@@ -1,4 +1,4 @@
-import type { NodeBorderStyles } from '../../../modules/state';
+import type { BorderStyles } from '../../../modules/state';
 import type { Node } from '../../../types/graph-element';
 import type AnimationHandler from '../AnimationHandler';
 type RingStyle = {
@@ -13,7 +13,7 @@ type RingStyle = {
  * a width of 0 and an empty color.
  * @param node {Node} - The node to get the ring styles for.
  * @param animationHandler {AnimationHandler} - The animation handler.
- * @param nodeBorderStyles {NodeBorderStyles} - The node border styles.
+ * @param nodeBorderStyles {BorderStyles} - The node border styles.
  * @returns {{ width: number, color: string }[]} - An array of ring styles.
  */
 export declare const getRingStyles: (node: Node, animationHandler: AnimationHandler, nodeBorderStyles: any) => RingStyle[];
@@ -51,8 +51,8 @@ export declare const findMinLength: (lines: any[], ctx: CanvasRenderingContext2D
  * @param node {Node} - The node to draw.
  * @param imageCache {any} - The image cache to use.
  * @param animationHandler {AnimationHandler} - The animation handler.
- * @param nodeBorderStyles {NodeBorderStyles} - The node border styles.
+ * @param nodeBorderStyles {BorderStyles} - The node border styles.
  * @param zoomLevel {number} - The current zoom level.
  */
-export declare const drawNode: (ctx: CanvasRenderingContext2D, node: Node, imageCache: any, animationHandler: AnimationHandler, nodeBorderStyles: NodeBorderStyles, zoomLevel?: number) => void;
+export declare const drawNode: (ctx: CanvasRenderingContext2D, node: Node, imageCache: any, animationHandler: AnimationHandler, nodeBorderStyles: BorderStyles, zoomLevel?: number) => void;
 export {};

package/dist/types/renderers/canvasrenderer/nodes/nodes.test.d.ts

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

package/dist/types/renderers/canvasrenderer/util.test.d.ts

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

package/dist/types/renderers/canvasrenderer/wordwrap.test.d.ts

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

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

@@ -31,10 +31,10 @@ export default class Controller implements ControllerInterface {
     constructor(options: {
         mainSceneRenderer?: Renderer;
         minimapRenderer?: Renderer;
-        state: NvlState;
+        state?: NvlState;
     });
     needsToRun(): boolean;
-    renderMainScene(positionArray: any): void;
+    renderMainScene(positionArray: Node[]): void;
     renderMinimap(positionArray: Node[]): void;
     checkForUpdates(nodes: DataSet<Node>, rels: DataSet<Relationship>): void;
     onResize(): void;

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

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

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

@@ -1,8 +1,7 @@
-/// <reference types="gl-matrix/index.js" />
 import { mat4 } from 'gl-matrix';
-import type { DataSet } from '../../modules/dataset.js';
-import type { NvlState } from '../../modules/state.js';
-import type { Node, Relationship } from '../../types/graph-element.js';
+import type { DataSet } from '../../modules/dataset';
+import type { NvlState } from '../../modules/state';
+import type { Node, Relationship } from '../../types/graph-element';
 export default class Renderer {
     private readonly nodeShader;
     private readonly nodeAnimShader;
@@ -24,9 +23,6 @@ export default class Renderer {
     private nodeDataByte;
     private relIdToIndex;
     private relData;
-    private containerWidth;
-    private containerHeight;
-    private nodeDataInt;
     private viewportBoxBuffer;
     private relBuffer;
     private nodeBuffer;

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

@@ -24,10 +24,37 @@ interface GraphElement {
     hovered?: boolean;
     /** The caption text size.*/
     captionSize?: number;
-    /** The caption align.*/
+    /**
+     * The caption align.
+     * @note Has no affect on self-referring relationships.
+     */
     captionAlign?: 'top' | 'bottom' | 'center';
-    /** The caption text and font style.*/
+    /**
+     * The caption text and font style.
+     * @note Captions are only visible when using the 'canvas' renderer.
+     */
     captions?: StyledCaption[];
+    /**
+     * An icon to be displayed anywhere on top of the graph element.
+     * @note Icons are expected to be square.
+     */
+    overlayIcon?: {
+        url: string;
+        /**
+         * The position of the icon relative to the node or relationship.
+         * @note The position is a percentage of the node or relationship size.
+         * `[1, 1]` is the bottom right corner of the node or relationship.
+         * `[-1, -1]` is the top left corner of the node or relationship.
+         * @defaultValue `[0, 0]`, the center of the node or relationship.
+         */
+        position?: number[];
+        /**
+         * The size of the icon relative to the node size or relationship caption size.
+         * @note The size is a percentage of the node size or relationship caption size.
+         * @defaultValue `1`, the same size as the node size or relationship caption size.
+         */
+        size?: number;
+    };
 }
 export declare const isValidNode: (node: unknown) => node is Node;
 /**
@@ -44,7 +71,12 @@ interface Node extends GraphElement {
     y?: number;
     /** Whether or not the current node is activated.*/
     activated?: boolean;
-    /** The icon to display inside the node.*/
+    /**
+     * The url to an icon to display inside the node.
+     * @note Icons are expected to be black. If the node's background color is dark,
+     * the icon will be inverted to white.
+     * @note Icons are expected to be square.
+     */
     icon?: string;
     /**
      * The DOM element to display on top of a node.

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

@@ -0,0 +1,16 @@
+import type { Node, Relationship } from './graph-element';
+export interface NvlWindow {
+    __Nvl_dumpNodes: (instanceId?: string) => Node[];
+    __Nvl_dumpRelationships: (instanceId?: string) => Relationship[];
+    __Nvl_getNodesOnScreen: (instanceId?: string) => {
+        nodes: Node[];
+        rels: Relationship[];
+    };
+    __Nvl_registerDoneCallback: (cb: () => void, instanceId: string) => void;
+    __Nvl_getZoomLevel: (instanceId?: string) => number;
+}
+declare global {
+    interface Window extends NvlWindow {
+    }
+    const SEGMENT_WRITE_KEY: string;
+}

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

@@ -0,0 +1 @@
+export declare const typedObjectEntries: <T>(obj: T) => [keyof T, T[keyof T]][];

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

@@ -10,6 +10,6 @@ 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) => RenderingContext;
+export declare const getWebGLContext: (canvas: HTMLCanvasElement) => WebGLRenderingContext | WebGL2RenderingContext;
 export declare const removeWebGLContext: (webGLCtx: WebGLRenderingContext) => void;
 export declare const checkWebGLAvailability: (canvas?: HTMLCanvasElement) => boolean;

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

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