@neo4j-nvl/react 2.0.0 → 2.1.0

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "@neo4j-nvl/react",
-  "version": "2.0.0",
+  "version": "2.1.0",
+  "type": "module",
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "homepage": "https://neo4j.com/docs/nvl/current/",
   "license": "SEE LICENSE IN 'LICENSE.txt'",
   "description": "React wrappers for the Neo4j Visualization Library",
@@ -15,8 +25,8 @@
     "url": "https://community.neo4j.com/c/neo4j-graph-platform/neo4j-bloom"
   },
   "scripts": {
-    "build": "yarn global:tsc",
-    "watch": "yarn global:tsc -w",
+    "build": "yarn global:tsc --noEmit && tsdown",
+    "watch": "tsdown --watch",
     "test": " yarn global:jest",
     "prepack": "cp ../../LICENSE.txt ./ && cp ../../CHANGELOG.md ./",
     "postpack": "rm LICENSE.txt && rm CHANGELOG.md",
@@ -26,22 +36,26 @@
     "LICENSE.txt",
     "lib"
   ],
+  "skills": [
+    "npm:@neo4j-nvl/base"
+  ],
   "devDependencies": {
     "@testing-library/dom": "10.4.1",
     "@testing-library/jest-dom": "5.17.0",
     "@testing-library/react": "16.3.0",
-    "@types/lodash": "4.17.21",
+    "@types/lodash-es": "4.17.12",
     "@types/react": "18.3.27",
     "react": "19.2.1",
-    "react-dom": "19.2.1"
+    "react-dom": "19.2.1",
+    "tsdown": "0.23.1"
   },
   "dependencies": {
-    "@neo4j-nvl/base": "2.0.0",
-    "@neo4j-nvl/interaction-handlers": "2.0.0",
-    "lodash": "4.18.1"
+    "@neo4j-nvl/base": "2.1.0",
+    "@neo4j-nvl/interaction-handlers": "2.1.0",
+    "lodash-es": "4.18.1"
   },
   "peerDependencies": {
-    "react": "18.0.0 || ^19.0.0",
-    "react-dom": "18.0.0 || ^19.0.0"
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
   }
 }

package/lib/__tests__/BasicNvlWrapper.test.d.ts

@@ -1 +0,0 @@
-import '@testing-library/jest-dom';

package/lib/__tests__/BasicNvlWrapper.test.js

@@ -1,159 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import NVL, { HierarchicalLayoutType } from '@neo4j-nvl/base';
-import '@testing-library/jest-dom';
-import { render } from '@testing-library/react';
-import { StrictMode } from 'react';
-import { BasicNvlWrapper } from '../basic-wrapper/BasicNvlWrapper';
-jest.mock('@neo4j-nvl/base');
-jest.mock('@neo4j-nvl/layout-workers');
-describe('BasicNvlWrapper', () => {
-    let setZoom;
-    let setPan;
-    let setZoomAndPan;
-    beforeEach(() => {
-        setZoom = jest.fn();
-        setPan = jest.fn();
-        setZoomAndPan = jest.fn();
-        jest.spyOn(NVL.prototype, 'setZoom').mockImplementation(setZoom);
-        jest.spyOn(NVL.prototype, 'setPan').mockImplementation(setPan);
-        jest.spyOn(NVL.prototype, 'setZoomAndPan').mockImplementation(setZoomAndPan);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    test('initialises NVL expectedly with an empty graph object and no other properties', () => {
-        render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [] }) }));
-        expect(NVL).toHaveBeenCalledWith(expect.any(HTMLDivElement), [], [], {}, {});
-    });
-    test('initialises NVL expectedly with a graph object and properties', () => {
-        const mockLayoutDoneFunction = jest.fn();
-        render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [{ id: '1' }, { id: '2' }], rels: [{ id: '12', from: '1', to: '2' }], nvlOptions: {
-                    renderer: 'canvas',
-                    layout: HierarchicalLayoutType,
-                    layoutOptions: { direction: 'down' }
-                }, nvlCallbacks: { onLayoutDone: mockLayoutDoneFunction } }) }));
-        expect(NVL).toHaveBeenCalledWith(expect.any(HTMLDivElement), [{ id: '1' }, { id: '2' }], [{ id: '12', from: '1', to: '2' }], { renderer: 'canvas', layout: HierarchicalLayoutType, layoutOptions: { direction: 'down' } }, {
-            onLayoutDone: mockLayoutDoneFunction
-        });
-    });
-    test('destroys NVL on unmount', () => {
-        const destroy = jest.fn();
-        jest.spyOn(NVL.prototype, 'destroy').mockImplementation(destroy);
-        const { unmount } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [] }) }));
-        unmount();
-        expect(NVL).toHaveBeenCalledTimes(1);
-        expect(destroy).toHaveBeenCalledTimes(1);
-    });
-    test('successfully re-initialises NVL when using React StrictMode', () => {
-        const destroy = jest.fn();
-        jest.spyOn(NVL.prototype, 'destroy').mockImplementation(destroy);
-        render(_jsx(StrictMode, { children: _jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [] }) }) }));
-        expect(NVL).toHaveBeenCalledTimes(2);
-        expect(destroy).toHaveBeenCalledTimes(1);
-    });
-    test('reapplies zoom and pan when re-initialising NVL with React StrictMode', () => {
-        const destroy = jest.fn();
-        jest.spyOn(NVL.prototype, 'destroy').mockImplementation(destroy);
-        render(_jsx(StrictMode, { children: _jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 10, y: 20 } }) }) }));
-        expect(NVL).toHaveBeenCalledTimes(2);
-        expect(destroy).toHaveBeenCalledTimes(1);
-        expect(setZoomAndPan).toHaveBeenCalledTimes(2);
-        expect(setZoomAndPan).toHaveBeenNthCalledWith(1, 1.5, 10, 20);
-        expect(setZoomAndPan).toHaveBeenNthCalledWith(2, 1.5, 10, 20);
-    });
-    test('calls setZoom when zoom property is provided', () => {
-        render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5 }) }));
-        expect(setZoom).toHaveBeenCalledWith(1.5);
-        expect(setZoom).toHaveBeenCalledTimes(1);
-    });
-    test('calls setPan when pan property is provided', () => {
-        render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], pan: { x: 10, y: 20 } }) }));
-        expect(setPan).toHaveBeenCalledWith(10, 20);
-        expect(setPan).toHaveBeenCalledTimes(1);
-    });
-    test('calls setZoomAndPan when both zoom and pan properties are provided', () => {
-        render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 10, y: 20 } }) }));
-        expect(setZoomAndPan).toHaveBeenCalledWith(1.5, 10, 20);
-        expect(setZoomAndPan).toHaveBeenCalledTimes(1);
-    });
-    test('does not call zoom/pan methods when properties are undefined', () => {
-        render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [] }) }));
-        expect(setZoom).not.toHaveBeenCalled();
-        expect(setPan).not.toHaveBeenCalled();
-        expect(setZoomAndPan).not.toHaveBeenCalled();
-    });
-    test('only calls setZoom when zoom changes', () => {
-        const { rerender } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5 }) }));
-        expect(setZoom).toHaveBeenCalledTimes(1);
-        expect(setZoom).toHaveBeenCalledWith(1.5);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5 }) }));
-        expect(setZoom).toHaveBeenCalledTimes(1);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 2.0 }) }));
-        expect(setZoom).toHaveBeenCalledTimes(2);
-        expect(setZoom).toHaveBeenCalledWith(2.0);
-        expect(setPan).not.toHaveBeenCalled();
-        expect(setZoomAndPan).not.toHaveBeenCalled();
-    });
-    test('only calls setPan when pan changes', () => {
-        const { rerender } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], pan: { x: 10, y: 20 } }) }));
-        expect(setPan).toHaveBeenCalledTimes(1);
-        expect(setPan).toHaveBeenCalledWith(10, 20);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], pan: { x: 10, y: 20 } }) }));
-        expect(setPan).toHaveBeenCalledTimes(1);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], pan: { x: 30, y: 40 } }) }));
-        expect(setPan).toHaveBeenCalledTimes(2);
-        expect(setPan).toHaveBeenCalledWith(30, 40);
-        expect(setZoom).not.toHaveBeenCalled();
-        expect(setZoomAndPan).not.toHaveBeenCalled();
-    });
-    test('calls setZoomAndPan when both zoom and pan change', () => {
-        const { rerender } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 10, y: 20 } }) }));
-        expect(setZoomAndPan).toHaveBeenCalledTimes(1);
-        expect(setZoomAndPan).toHaveBeenCalledWith(1.5, 10, 20);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 10, y: 20 } }) }));
-        expect(setZoomAndPan).toHaveBeenCalledTimes(1);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 2.0, pan: { x: 30, y: 40 } }) }));
-        expect(setZoomAndPan).toHaveBeenCalledTimes(2);
-        expect(setZoomAndPan).toHaveBeenCalledWith(2.0, 30, 40);
-        expect(setZoom).not.toHaveBeenCalled();
-        expect(setPan).not.toHaveBeenCalled();
-    });
-    test('calls appropriate methods when only zoom changes while both are set', () => {
-        const { rerender } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 10, y: 20 } }) }));
-        expect(setZoomAndPan).toHaveBeenCalledTimes(1);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 2.0, pan: { x: 10, y: 20 } }) }));
-        expect(setZoom).toHaveBeenCalledTimes(1);
-        expect(setZoom).toHaveBeenCalledWith(2.0);
-        expect(setZoomAndPan).toHaveBeenCalledTimes(1);
-        expect(setPan).not.toHaveBeenCalled();
-    });
-    test('calls appropriate methods when only pan changes while both are set', () => {
-        const { rerender } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 10, y: 20 } }) }));
-        expect(setZoomAndPan).toHaveBeenCalledTimes(1);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 30, y: 40 } }) }));
-        expect(setPan).toHaveBeenCalledTimes(1);
-        expect(setPan).toHaveBeenCalledWith(30, 40);
-        expect(setZoomAndPan).toHaveBeenCalledTimes(1);
-        expect(setZoom).not.toHaveBeenCalled();
-    });
-    test('calls setLayout when nvlOptions.layout changes', () => {
-        const setLayout = jest.fn();
-        jest.spyOn(NVL.prototype, 'setLayout').mockImplementation(setLayout);
-        const { rerender } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], nvlOptions: { layout: HierarchicalLayoutType } }) }));
-        expect(setLayout).toHaveBeenCalledWith(HierarchicalLayoutType);
-        expect(setLayout).toHaveBeenCalledTimes(1);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], nvlOptions: { layout: 'forceDirected' } }) }));
-        expect(setLayout).toHaveBeenCalledWith('forceDirected');
-        expect(setLayout).toHaveBeenCalledTimes(2);
-    });
-    test('calls setLayoutOptions when nvlOptions.layoutOptions changes', () => {
-        const setLayoutOptions = jest.fn();
-        jest.spyOn(NVL.prototype, 'setLayoutOptions').mockImplementation(setLayoutOptions);
-        const { rerender } = render(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], nvlOptions: { layoutOptions: { direction: 'down' } } }) }));
-        expect(setLayoutOptions).toHaveBeenCalledWith({ direction: 'down' });
-        expect(setLayoutOptions).toHaveBeenCalledTimes(1);
-        rerender(_jsx("div", { children: _jsx(BasicNvlWrapper, { nodes: [], rels: [], nvlOptions: { layoutOptions: { direction: 'up' } } }) }));
-        expect(setLayoutOptions).toHaveBeenCalledWith({ direction: 'up' });
-        expect(setLayoutOptions).toHaveBeenCalledTimes(2);
-    });
-});

package/lib/__tests__/InteractiveNvlWrapper.test.d.ts

@@ -1 +0,0 @@
-import '@testing-library/jest-dom';

package/lib/__tests__/InteractiveNvlWrapper.test.js

@@ -1,396 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import NVL, { HierarchicalLayoutType } from '@neo4j-nvl/base';
-import { BoxSelectInteraction, ClickInteraction, DragNodeInteraction, DrawInteraction, HoverInteraction, KeyboardInteraction, LassoInteraction, PanInteraction, ZoomInteraction } from '@neo4j-nvl/interaction-handlers';
-import '@testing-library/jest-dom';
-import { render } from '@testing-library/react';
-import { StrictMode, act, createRef } from 'react';
-import { InteractiveNvlWrapper } from '../interactive-nvl-wrapper/InteractiveNvlWrapper';
-jest.mock('@neo4j-nvl/base');
-jest.mock('@neo4j-nvl/layout-workers');
-jest.mock('@neo4j-nvl/interaction-handlers');
-const MockedNVL = NVL;
-let mockOnInitialization;
-HoverInteraction.prototype.callbackMap = new Map();
-HoverInteraction.prototype.updateCallback = jest.fn();
-HoverInteraction.prototype.removeCallback = jest.fn();
-HoverInteraction.prototype.destroy = jest.fn();
-PanInteraction.prototype.callbackMap = new Map();
-PanInteraction.prototype.updateCallback = jest.fn();
-PanInteraction.prototype.removeCallback = jest.fn();
-PanInteraction.prototype.destroy = jest.fn();
-ClickInteraction.prototype.callbackMap = new Map();
-ClickInteraction.prototype.updateCallback = jest.fn();
-ClickInteraction.prototype.removeCallback = jest.fn();
-ClickInteraction.prototype.destroy = jest.fn();
-ZoomInteraction.prototype.callbackMap = new Map();
-ZoomInteraction.prototype.updateCallback = jest.fn();
-ZoomInteraction.prototype.removeCallback = jest.fn();
-ZoomInteraction.prototype.destroy = jest.fn();
-DragNodeInteraction.prototype.callbackMap = new Map();
-DragNodeInteraction.prototype.updateCallback = jest.fn();
-DragNodeInteraction.prototype.removeCallback = jest.fn();
-DragNodeInteraction.prototype.destroy = jest.fn();
-DrawInteraction.prototype.callbackMap = new Map();
-DrawInteraction.prototype.updateCallback = jest.fn();
-DrawInteraction.prototype.removeCallback = jest.fn();
-DrawInteraction.prototype.destroy = jest.fn();
-BoxSelectInteraction.prototype.callbackMap = new Map();
-BoxSelectInteraction.prototype.updateCallback = jest.fn();
-BoxSelectInteraction.prototype.removeCallback = jest.fn();
-BoxSelectInteraction.prototype.destroy = jest.fn();
-LassoInteraction.prototype.callbackMap = new Map();
-LassoInteraction.prototype.updateCallback = jest.fn();
-LassoInteraction.prototype.removeCallback = jest.fn();
-LassoInteraction.prototype.destroy = jest.fn();
-KeyboardInteraction.prototype.callbackMap = new Map();
-KeyboardInteraction.prototype.updateCallback = jest.fn();
-KeyboardInteraction.prototype.removeCallback = jest.fn();
-KeyboardInteraction.prototype.destroy = jest.fn();
-let mockDestroy;
-let destroyHoverInteraction;
-let destroyPanInteraction;
-describe('InteractiveNvlWrapper', () => {
-    beforeEach(() => {
-        jest.spyOn(NVL.prototype, 'getContainer').mockImplementation(() => document.createElement('div'));
-        MockedNVL.mockImplementation((_container, _nodes, _rels, _options, callbacks) => {
-            mockOnInitialization = callbacks.onInitialization;
-            return {
-                getContainer: () => document.createElement('div'),
-                destroy: mockDestroy,
-                setLayout: jest.fn(),
-                setLayoutOptions: jest.fn(),
-                setRenderer: jest.fn()
-            };
-        });
-        mockDestroy = jest.fn();
-        destroyHoverInteraction = jest.fn();
-        destroyPanInteraction = jest.fn();
-        jest.spyOn(NVL.prototype, 'destroy').mockImplementation(mockDestroy);
-        jest.spyOn(HoverInteraction.prototype, 'destroy').mockImplementation(destroyHoverInteraction);
-        jest.spyOn(PanInteraction.prototype, 'destroy').mockImplementation(destroyPanInteraction);
-        jest.spyOn(ClickInteraction.prototype, 'destroy').mockImplementation(jest.fn());
-        jest.spyOn(ZoomInteraction.prototype, 'destroy').mockImplementation(jest.fn());
-        jest.spyOn(DragNodeInteraction.prototype, 'destroy').mockImplementation(jest.fn());
-        jest.spyOn(DrawInteraction.prototype, 'destroy').mockImplementation(jest.fn());
-        jest.spyOn(BoxSelectInteraction.prototype, 'destroy').mockImplementation(jest.fn());
-        jest.spyOn(LassoInteraction.prototype, 'destroy').mockImplementation(jest.fn());
-        jest.spyOn(KeyboardInteraction.prototype, 'destroy').mockImplementation(jest.fn());
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    test('initialises NVL expectedly with an empty graph object and no other properties', () => {
-        render(_jsx("div", { children: _jsx(InteractiveNvlWrapper, { nodes: [], rels: [] }) }));
-        expect(NVL).toHaveBeenCalledWith(expect.any(HTMLDivElement), [], [], {}, { onInitialization: mockOnInitialization });
-    });
-    test('initialises NVL expectedly with a graph object and properties', () => {
-        const mockLayoutDoneFunction = jest.fn();
-        render(_jsx(InteractiveNvlWrapper, { nodes: [{ id: '1' }, { id: '2' }], rels: [{ id: '12', from: '1', to: '2' }], nvlOptions: {
-                renderer: 'canvas',
-                layout: HierarchicalLayoutType,
-                layoutOptions: { direction: 'down' }
-            }, nvlCallbacks: { onLayoutDone: mockLayoutDoneFunction } }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        expect(NVL).toHaveBeenCalledWith(expect.any(HTMLDivElement), [{ id: '1' }, { id: '2' }], [{ id: '12', from: '1', to: '2' }], { renderer: 'canvas', layout: HierarchicalLayoutType, layoutOptions: { direction: 'down' } }, {
-            onLayoutDone: mockLayoutDoneFunction,
-            onInitialization: mockOnInitialization
-        });
-    });
-    test('initialises expected interaction handlers with correct options', () => {
-        const myNvlRef = createRef();
-        render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], ref: myNvlRef, mouseEventCallbacks: {
-                onHover: true,
-                onPan: true
-            }, interactionOptions: {
-                drawShadowOnHover: true
-            } }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        expect(HoverInteraction).toHaveBeenCalledWith(myNvlRef.current, { drawShadowOnHover: true });
-        expect(PanInteraction).toHaveBeenCalledWith(myNvlRef.current, { drawShadowOnHover: true });
-        expect(HoverInteraction).toHaveBeenCalledTimes(1);
-        expect(PanInteraction).toHaveBeenCalledTimes(1);
-        expect(ClickInteraction).not.toHaveBeenCalled();
-        expect(DragNodeInteraction).not.toHaveBeenCalled();
-        expect(DrawInteraction).not.toHaveBeenCalled();
-        expect(ZoomInteraction).not.toHaveBeenCalled();
-        expect(BoxSelectInteraction).not.toHaveBeenCalled();
-        expect(LassoInteraction).not.toHaveBeenCalled();
-        expect(KeyboardInteraction).not.toHaveBeenCalled();
-    });
-    test.each([
-        {
-            name: 'HoverInteraction',
-            InteractionClass: HoverInteraction,
-            callback: { onHover: jest.fn() },
-            options: { drawShadowOnHover: true }
-        },
-        {
-            name: 'ClickInteraction with onCanvasClick',
-            InteractionClass: ClickInteraction,
-            callback: { onCanvasClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'ClickInteraction with onCanvasDoubleClick',
-            InteractionClass: ClickInteraction,
-            callback: { onCanvasDoubleClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'ClickInteraction with onCanvasRightClick',
-            InteractionClass: ClickInteraction,
-            callback: { onCanvasRightClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'ClickInteraction with onNodeClick',
-            InteractionClass: ClickInteraction,
-            callback: { onNodeClick: jest.fn() },
-            options: { selectOnClick: true }
-        },
-        {
-            name: 'ClickInteraction with onNodeDoubleClick',
-            InteractionClass: ClickInteraction,
-            callback: { onNodeDoubleClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'ClickInteraction with onNodeRightClick',
-            InteractionClass: ClickInteraction,
-            callback: { onNodeRightClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'ClickInteraction with onRelationshipClick',
-            InteractionClass: ClickInteraction,
-            callback: { onRelationshipClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'ClickInteraction with onRelationshipDoubleClick',
-            InteractionClass: ClickInteraction,
-            callback: { onRelationshipDoubleClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'ClickInteraction with onRelationshipRightClick',
-            InteractionClass: ClickInteraction,
-            callback: { onRelationshipRightClick: jest.fn() },
-            options: { selectOnClick: false }
-        },
-        {
-            name: 'PanInteraction',
-            InteractionClass: PanInteraction,
-            callback: { onPan: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'ZoomInteraction',
-            InteractionClass: ZoomInteraction,
-            callback: { onZoomAndPan: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'DragNodeInteraction with onDrag',
-            InteractionClass: DragNodeInteraction,
-            callback: { onDrag: jest.fn() },
-            options: { selectOnRelease: false }
-        },
-        {
-            name: 'DragNodeInteraction with onDragStart',
-            InteractionClass: DragNodeInteraction,
-            callback: { onDragStart: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'DragNodeInteraction with onDragEnd',
-            InteractionClass: DragNodeInteraction,
-            callback: { onDragEnd: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'DrawInteraction with onHoverNodeMargin',
-            InteractionClass: DrawInteraction,
-            callback: { onHoverNodeMargin: jest.fn() },
-            options: { excludeNodeMargin: false }
-        },
-        {
-            name: 'DrawInteraction with onDrawStarted',
-            InteractionClass: DrawInteraction,
-            callback: { onDrawStarted: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'DrawInteraction with onDrawEnded',
-            InteractionClass: DrawInteraction,
-            callback: { onDrawEnded: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'BoxSelectInteraction with onBoxStarted',
-            InteractionClass: BoxSelectInteraction,
-            callback: { onBoxStarted: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'BoxSelectInteraction with onBoxSelect',
-            InteractionClass: BoxSelectInteraction,
-            callback: { onBoxSelect: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'LassoInteraction with onLassoStarted',
-            InteractionClass: LassoInteraction,
-            callback: { onLassoStarted: jest.fn() },
-            options: {}
-        },
-        {
-            name: 'LassoInteraction with onLassoSelect',
-            InteractionClass: LassoInteraction,
-            callback: { onLassoSelect: jest.fn() },
-            options: {}
-        }
-    ])('initialises $name when its callback is provided', ({ InteractionClass, callback, options }) => {
-        const myNvlRef = createRef();
-        render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], ref: myNvlRef, mouseEventCallbacks: callback, interactionOptions: options }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        expect(InteractionClass).toHaveBeenCalledWith(myNvlRef.current, options);
-        expect(InteractionClass).toHaveBeenCalledTimes(1);
-    });
-    test.each([
-        {
-            name: 'KeyboardInteraction with onKeyDown',
-            callback: { onKeyDown: jest.fn() }
-        },
-        {
-            name: 'KeyboardInteraction with onKeyUp',
-            callback: { onKeyUp: jest.fn() }
-        },
-        {
-            name: 'KeyboardInteraction with onNodeFocus',
-            callback: { onNodeFocus: jest.fn() }
-        },
-        {
-            name: 'KeyboardInteraction with onNodeBlur',
-            callback: { onNodeBlur: jest.fn() }
-        },
-        {
-            name: 'KeyboardInteraction with onRelationshipFocus',
-            callback: { onRelationshipFocus: jest.fn() }
-        },
-        {
-            name: 'KeyboardInteraction with onRelationshipBlur',
-            callback: { onRelationshipBlur: jest.fn() }
-        },
-        {
-            name: 'KeyboardInteraction with onCanvasFocus',
-            callback: { onCanvasFocus: jest.fn() }
-        },
-        {
-            name: 'KeyboardInteraction with onCanvasBlur',
-            callback: { onCanvasBlur: jest.fn() }
-        }
-    ])('initialises $name when its callback is provided', ({ callback }) => {
-        const myNvlRef = createRef();
-        render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], ref: myNvlRef, keyboardEventCallbacks: callback }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        expect(KeyboardInteraction).toHaveBeenCalledWith(myNvlRef.current, expect.objectContaining({}));
-        expect(KeyboardInteraction).toHaveBeenCalledTimes(1);
-    });
-    test('does not attempt to initialize interaction handlers if NVL container is not available', () => {
-        const myNvlRef = createRef();
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        jest.spyOn(NVL.prototype, 'getContainer').mockImplementation(() => null);
-        render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], ref: myNvlRef, mouseEventCallbacks: {
-                onHover: true
-            }, interactionOptions: {
-                drawShadowOnHover: true
-            } }));
-        expect(HoverInteraction).not.toHaveBeenCalled();
-        expect(NVL).toHaveBeenCalledTimes(1);
-    });
-    test('destroys NVL and active interaction handlers on unmount', () => {
-        const { unmount } = render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], mouseEventCallbacks: {
-                onHover: true
-            } }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        unmount();
-        expect(mockDestroy).toHaveBeenCalledTimes(1);
-        expect(destroyHoverInteraction).toHaveBeenCalledTimes(1);
-        expect(destroyPanInteraction).not.toHaveBeenCalled();
-    });
-    test('successfully re-initialises NVL and active interaction handlers when using React StrictMode', () => {
-        const myNvlRef = createRef();
-        render(_jsx(StrictMode, { children: _jsx(InteractiveNvlWrapper, { nodes: [], rels: [], ref: myNvlRef, mouseEventCallbacks: {
-                    onHover: true
-                }, interactionOptions: {
-                    drawShadowOnHover: true
-                } }) }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        expect(NVL).toHaveBeenCalledTimes(2);
-        expect(HoverInteraction).toHaveBeenCalledTimes(2);
-        expect(HoverInteraction).toHaveBeenCalledWith(myNvlRef.current, { drawShadowOnHover: true });
-        expect(mockDestroy).toHaveBeenCalledTimes(1);
-        expect(destroyHoverInteraction).toHaveBeenCalledTimes(1);
-        expect(destroyPanInteraction).not.toHaveBeenCalled();
-        expect(DragNodeInteraction).not.toHaveBeenCalled();
-        expect(DrawInteraction).not.toHaveBeenCalled();
-        expect(ZoomInteraction).not.toHaveBeenCalled();
-        expect(BoxSelectInteraction).not.toHaveBeenCalled();
-        expect(LassoInteraction).not.toHaveBeenCalled();
-        expect(KeyboardInteraction).not.toHaveBeenCalled();
-    });
-    test('destroys keyboard interaction on unmount', () => {
-        const destroyKeyboardInteraction = jest.fn();
-        jest.spyOn(KeyboardInteraction.prototype, 'destroy').mockImplementation(destroyKeyboardInteraction);
-        const { unmount } = render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], keyboardEventCallbacks: {
-                onKeyDown: true
-            } }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        unmount();
-        expect(destroyKeyboardInteraction).toHaveBeenCalledTimes(1);
-    });
-    test('also calls custom callbacks on initialization', () => {
-        const customOnInitializationCallback = jest.fn();
-        render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], nvlCallbacks: { onInitialization: customOnInitializationCallback } }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        expect(customOnInitializationCallback).toHaveBeenCalledTimes(1);
-    });
-    test('passes zoom and pan properties to BasicNvlWrapper', () => {
-        const setZoom = jest.fn();
-        const setPan = jest.fn();
-        const setZoomAndPan = jest.fn();
-        MockedNVL.mockImplementation(() => ({
-            getContainer: () => document.createElement('div'),
-            destroy: jest.fn(),
-            setLayout: jest.fn(),
-            setLayoutOptions: jest.fn(),
-            setNodePositions: jest.fn(),
-            setZoom,
-            setPan,
-            setZoomAndPan
-        }));
-        render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], zoom: 1.5, pan: { x: 10, y: 20 } }));
-        act(() => {
-            mockOnInitialization?.();
-        });
-        expect(setZoomAndPan).toHaveBeenCalledWith(1.5, 10, 20);
-    });
-});

package/lib/__tests__/StaticPictureWrapper.test.d.ts

@@ -1 +0,0 @@
-import '@testing-library/jest-dom';