@neo4j-nvl/react 0.3.8-d30e7f77 → 0.3.8-d40957ab

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to NVL will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.3.9] - 2025-07-23
+
+The 0.3.9 release contains several fixes for NVL's interaction handler and adds a new method to NVL to directly extract image data from an NVL instance:
+
+### Added
+
+* new export method for image data url called `.getImageDataUrl`
+* new callback triggered when NVL is fully initialized called `onInitialization`.
+
+### Changed
+
+* updated license agreement in `LICENSE.txt`.
+* prevent zoom interaction handler to zoom in NVL when ctrl or meta key is pressed.
+* improve handling of leaving NVL container while performing selection using the lasso and box interaction handlers.
+
+### Fixed
+
+* fix error on onDragEnd callback.
+* fix race condition when hovering over an element that is being dismissed.
+* fix nodes moving on clicks.
+* prevent crash when providing non-existent node ids to `.setNodePositions` method.
+* fix slow zoom speed for touchpads in zoom interaction handler.
+* Ensure interaction handlers in react component waits for NVL to be initialised first.
+
 ## [0.3.8] - 2025-03-18
 
 This release contains a fix for the [NVL result transformer](https://neo4j.com/docs/api/nvl/current/functions/_neo4j_nvl_base.nvlResultTransformer.html).

package/lib/__tests__/InteractiveNvlWrapper.test.js

@@ -2,38 +2,70 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import NVL, { HierarchicalLayoutType } from '@neo4j-nvl/base';
 import { BoxSelectInteraction, ClickInteraction, DragNodeInteraction, DrawInteraction, HoverInteraction, LassoInteraction, PanInteraction, ZoomInteraction } from '@neo4j-nvl/interaction-handlers';
 import '@testing-library/jest-dom';
-import { render } from '@testing-library/react';
+import { act, render } from '@testing-library/react';
 import React, { 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');
+let mockOnInitialization;
 HoverInteraction.prototype.callbackMap = new Map();
 PanInteraction.prototype.callbackMap = new Map();
+let mockDestroy;
+let destroyHoverInteraction;
+let destroyPanInteraction;
 describe('InteractiveNvlWrapper', () => {
+    beforeEach(() => {
+        jest.spyOn(NVL.prototype, 'getContainer').mockImplementation(() => document.createElement('div'));
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        NVL.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);
+    });
     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), [], [], {}, {});
+        expect(NVL).toHaveBeenCalledWith(expect.any(HTMLDivElement), [], [], {}, { onInitialization: expect.any(Function) });
     });
     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' }], layout: HierarchicalLayoutType, layoutOptions: { enableCytoscape: true }, nvlOptions: { renderer: 'canvas' }, 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: { enableCytoscape: true } }, {
-            onLayoutDone: mockLayoutDoneFunction
+            onLayoutDone: mockLayoutDoneFunction,
+            onInitialization: expect.any(Function)
         });
     });
     test('initialises expected interaction handlers with correct options', () => {
         const myNvlRef = createRef();
-        jest.spyOn(NVL.prototype, 'getContainer').mockImplementation(() => document.createElement('div'));
         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);
@@ -45,40 +77,45 @@ describe('InteractiveNvlWrapper', () => {
         expect(BoxSelectInteraction).not.toHaveBeenCalled();
         expect(LassoInteraction).not.toHaveBeenCalled();
     });
+    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 destroy = jest.fn();
-        jest.spyOn(NVL.prototype, 'destroy').mockImplementation(destroy);
-        const destroyHoverInteraction = jest.fn();
-        jest.spyOn(HoverInteraction.prototype, 'destroy').mockImplementation(destroyHoverInteraction);
-        const destroyPanInteraction = jest.fn();
-        jest.spyOn(PanInteraction.prototype, 'destroy').mockImplementation(destroyPanInteraction);
-        jest.spyOn(NVL.prototype, 'getContainer').mockImplementation(() => document.createElement('div'));
         const { unmount } = render(_jsx(InteractiveNvlWrapper, { nodes: [], rels: [], mouseEventCallbacks: {
                 onHover: true
             } }));
+        act(() => {
+            mockOnInitialization?.();
+        });
         unmount();
-        expect(destroy).toHaveBeenCalledTimes(1);
+        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 destroy = jest.fn();
-        jest.spyOn(NVL.prototype, 'destroy').mockImplementation(destroy);
-        const destroyHoverInteraction = jest.fn();
-        jest.spyOn(HoverInteraction.prototype, 'destroy').mockImplementation(destroyHoverInteraction);
-        const destroyPanInteraction = jest.fn();
-        jest.spyOn(PanInteraction.prototype, 'destroy').mockImplementation(destroyPanInteraction);
-        jest.spyOn(NVL.prototype, 'getContainer').mockImplementation(() => document.createElement('div'));
         const myNvlRef = createRef();
         render(_jsx(React.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(destroy).toHaveBeenCalledTimes(1);
+        expect(mockDestroy).toHaveBeenCalledTimes(1);
         expect(destroyHoverInteraction).toHaveBeenCalledTimes(1);
         expect(destroyPanInteraction).not.toHaveBeenCalled();
         expect(DragNodeInteraction).not.toHaveBeenCalled();
@@ -87,4 +124,12 @@ describe('InteractiveNvlWrapper', () => {
         expect(BoxSelectInteraction).not.toHaveBeenCalled();
         expect(LassoInteraction).not.toHaveBeenCalled();
     });
+    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);
+    });
 });

package/lib/interactive-nvl-wrapper/InteractionHandlers.d.ts

@@ -0,0 +1,10 @@
+import type NVL from '@neo4j-nvl/base';
+import type { MutableRefObject } from 'react';
+import type { InteractionOptions, MouseEventCallbacks } from './types';
+interface InteractionHandlersProps {
+    nvlRef: MutableRefObject<NVL | null>;
+    mouseEventCallbacks: MouseEventCallbacks;
+    interactionOptions: InteractionOptions;
+}
+export declare const InteractionHandlers: React.FC<InteractionHandlersProps>;
+export {};

package/lib/interactive-nvl-wrapper/InteractionHandlers.js

@@ -0,0 +1,45 @@
+import { BoxSelectInteraction, ClickInteraction, DragNodeInteraction, DrawInteraction, HoverInteraction, LassoInteraction, PanInteraction, ZoomInteraction } from '@neo4j-nvl/interaction-handlers';
+import { useEffect, useRef } from 'react';
+import { destroyInteraction, useInteraction } from './hooks';
+export const InteractionHandlers = ({ nvlRef, mouseEventCallbacks, interactionOptions }) => {
+    const hoverInteraction = useRef(null);
+    const clickInteraction = useRef(null);
+    const panInteraction = useRef(null);
+    const zoomInteraction = useRef(null);
+    const dragNodeInteraction = useRef(null);
+    const drawInteraction = useRef(null);
+    const multiSelectInteraction = useRef(null);
+    const lassoInteraction = useRef(null);
+    useInteraction(HoverInteraction, hoverInteraction, mouseEventCallbacks.onHover, 'onHover', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onNodeClick, 'onNodeClick', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onNodeDoubleClick, 'onNodeDoubleClick', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onNodeRightClick, 'onNodeRightClick', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onRelationshipClick, 'onRelationshipClick', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onRelationshipDoubleClick, 'onRelationshipDoubleClick', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onRelationshipRightClick, 'onRelationshipRightClick', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onCanvasClick, 'onCanvasClick', nvlRef, interactionOptions);
+    useInteraction(ClickInteraction, clickInteraction, mouseEventCallbacks.onCanvasRightClick, 'onCanvasRightClick', nvlRef, interactionOptions);
+    useInteraction(PanInteraction, panInteraction, mouseEventCallbacks.onPan, 'onPan', nvlRef, interactionOptions);
+    useInteraction(ZoomInteraction, zoomInteraction, mouseEventCallbacks.onZoom, 'onZoom', nvlRef, interactionOptions);
+    useInteraction(DragNodeInteraction, dragNodeInteraction, mouseEventCallbacks.onDrag, 'onDrag', nvlRef, interactionOptions);
+    useInteraction(DragNodeInteraction, dragNodeInteraction, mouseEventCallbacks.onDragStart, 'onDragStart', nvlRef, interactionOptions);
+    useInteraction(DragNodeInteraction, dragNodeInteraction, mouseEventCallbacks.onDragEnd, 'onDragEnd', nvlRef, interactionOptions);
+    useInteraction(DrawInteraction, drawInteraction, mouseEventCallbacks.onHoverNodeMargin, 'onHoverNodeMargin', nvlRef, interactionOptions);
+    useInteraction(DrawInteraction, drawInteraction, mouseEventCallbacks.onDrawStarted, 'onDrawStarted', nvlRef, interactionOptions);
+    useInteraction(DrawInteraction, drawInteraction, mouseEventCallbacks.onDrawEnded, 'onDrawEnded', nvlRef, interactionOptions);
+    useInteraction(BoxSelectInteraction, multiSelectInteraction, mouseEventCallbacks.onBoxStarted, 'onBoxStarted', nvlRef, interactionOptions);
+    useInteraction(BoxSelectInteraction, multiSelectInteraction, mouseEventCallbacks.onBoxSelect, 'onBoxSelect', nvlRef, interactionOptions);
+    useInteraction(LassoInteraction, lassoInteraction, mouseEventCallbacks.onLassoStarted, 'onLassoStarted', nvlRef, interactionOptions);
+    useInteraction(LassoInteraction, lassoInteraction, mouseEventCallbacks.onLassoSelect, 'onLassoSelect', nvlRef, interactionOptions);
+    useEffect(() => () => {
+        destroyInteraction(hoverInteraction);
+        destroyInteraction(clickInteraction);
+        destroyInteraction(panInteraction);
+        destroyInteraction(zoomInteraction);
+        destroyInteraction(dragNodeInteraction);
+        destroyInteraction(drawInteraction);
+        destroyInteraction(multiSelectInteraction);
+        destroyInteraction(lassoInteraction);
+    }, []);
+    return null;
+};

package/lib/interactive-nvl-wrapper/InteractiveNvlWrapper.js

@@ -1,9 +1,8 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { BoxSelectInteraction, ClickInteraction, DragNodeInteraction, DrawInteraction, HoverInteraction, LassoInteraction, PanInteraction, ZoomInteraction } from '@neo4j-nvl/interaction-handlers';
-import { forwardRef, memo, useEffect, useRef } from 'react';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, memo, useCallback, useRef, useState } from 'react';
 import { BasicNvlWrapper } from '../basic-wrapper/BasicNvlWrapper';
 import { INTERACTIVE_WRAPPER_ID } from '../utils/constants';
-import { destroyInteraction, useInteraction } from './hooks';
+import { InteractionHandlers } from './InteractionHandlers';
 const options = {
     selectOnClick: false,
     drawShadowOnHover: true,
@@ -24,45 +23,24 @@ const options = {
 export const InteractiveNvlWrapper = memo(forwardRef(({ nodes, rels, layout, layoutOptions, onInitializationError, mouseEventCallbacks = {}, nvlCallbacks = {}, nvlOptions = {}, interactionOptions = options, ...nvlEvents }, nvlRef) => {
     const newNvlRef = useRef(null);
     const myNvlRef = nvlRef ?? newNvlRef;
-    const { onHover, onNodeClick, onNodeDoubleClick, onNodeRightClick, onRelationshipClick, onRelationshipDoubleClick, onRelationshipRightClick, onCanvasClick, onCanvasRightClick, onPan, onZoom, onDrag, onDragStart, onDragEnd, onDrawStarted, onDrawEnded, onHoverNodeMargin, onBoxStarted, onBoxSelect, onLassoStarted, onLassoSelect } = mouseEventCallbacks;
-    const hoverInteraction = useRef(null);
-    const clickInteraction = useRef(null);
-    const panInteraction = useRef(null);
-    const zoomInteraction = useRef(null);
-    const dragNodeInteraction = useRef(null);
-    const drawInteraction = useRef(null);
-    const multiSelectInteraction = useRef(null);
-    const lassoInteraction = useRef(null);
-    useInteraction(HoverInteraction, hoverInteraction, onHover, 'onHover', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onNodeClick, 'onNodeClick', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onNodeDoubleClick, 'onNodeDoubleClick', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onNodeRightClick, 'onNodeRightClick', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onRelationshipClick, 'onRelationshipClick', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onRelationshipDoubleClick, 'onRelationshipDoubleClick', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onRelationshipRightClick, 'onRelationshipRightClick', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onCanvasClick, 'onCanvasClick', myNvlRef, interactionOptions);
-    useInteraction(ClickInteraction, clickInteraction, onCanvasRightClick, 'onCanvasRightClick', myNvlRef, interactionOptions);
-    useInteraction(PanInteraction, panInteraction, onPan, 'onPan', myNvlRef, interactionOptions);
-    useInteraction(ZoomInteraction, zoomInteraction, onZoom, 'onZoom', myNvlRef, interactionOptions);
-    useInteraction(DragNodeInteraction, dragNodeInteraction, onDrag, 'onDrag', myNvlRef, interactionOptions);
-    useInteraction(DragNodeInteraction, dragNodeInteraction, onDragStart, 'onDragStart', myNvlRef, interactionOptions);
-    useInteraction(DragNodeInteraction, dragNodeInteraction, onDragEnd, 'onDragEnd', myNvlRef, interactionOptions);
-    useInteraction(DrawInteraction, drawInteraction, onHoverNodeMargin, 'onHoverNodeMargin', myNvlRef, interactionOptions);
-    useInteraction(DrawInteraction, drawInteraction, onDrawStarted, 'onDrawStarted', myNvlRef, interactionOptions);
-    useInteraction(DrawInteraction, drawInteraction, onDrawEnded, 'onDrawEnded', myNvlRef, interactionOptions);
-    useInteraction(BoxSelectInteraction, multiSelectInteraction, onBoxStarted, 'onBoxStarted', myNvlRef, interactionOptions);
-    useInteraction(BoxSelectInteraction, multiSelectInteraction, onBoxSelect, 'onBoxSelect', myNvlRef, interactionOptions);
-    useInteraction(LassoInteraction, lassoInteraction, onLassoStarted, 'onLassoStarted', myNvlRef, interactionOptions);
-    useInteraction(LassoInteraction, lassoInteraction, onLassoSelect, 'onLassoSelect', myNvlRef, interactionOptions);
-    useEffect(() => () => {
-        destroyInteraction(hoverInteraction);
-        destroyInteraction(clickInteraction);
-        destroyInteraction(panInteraction);
-        destroyInteraction(zoomInteraction);
-        destroyInteraction(dragNodeInteraction);
-        destroyInteraction(drawInteraction);
-        destroyInteraction(multiSelectInteraction);
-        destroyInteraction(lassoInteraction);
+    const [isNvlInitialized, setIsNvlInitialized] = useState(false);
+    const handleInitialization = useCallback(() => {
+        setIsNvlInitialized(true);
     }, []);
-    return (_jsx(BasicNvlWrapper, { ref: myNvlRef, nodes: nodes, id: INTERACTIVE_WRAPPER_ID, rels: rels, nvlOptions: nvlOptions, nvlCallbacks: nvlCallbacks, layout: layout, layoutOptions: layoutOptions, onInitializationError: onInitializationError, ...nvlEvents }));
+    const handleInitializationError = useCallback((error) => {
+        setIsNvlInitialized(false);
+        if (onInitializationError) {
+            onInitializationError(error);
+        }
+    }, [onInitializationError]);
+    const setupInteractions = isNvlInitialized && myNvlRef.current !== null;
+    return (_jsxs(_Fragment, { children: [_jsx(BasicNvlWrapper, { ref: myNvlRef, nodes: nodes, id: INTERACTIVE_WRAPPER_ID, rels: rels, nvlOptions: nvlOptions, nvlCallbacks: {
+                    ...nvlCallbacks,
+                    onInitialization: () => {
+                        if (nvlCallbacks.onInitialization !== undefined) {
+                            nvlCallbacks.onInitialization();
+                        }
+                        handleInitialization();
+                    }
+                }, layout: layout, layoutOptions: layoutOptions, onInitializationError: handleInitializationError, ...nvlEvents }), setupInteractions && (_jsx(InteractionHandlers, { nvlRef: myNvlRef, mouseEventCallbacks: mouseEventCallbacks, interactionOptions: interactionOptions }))] }));
 }));

package/lib/interactive-nvl-wrapper/hooks.js

@@ -6,14 +6,14 @@ export const destroyInteraction = (interactionRef) => {
 };
 export const useInteraction = (Interaction, interactionRef, callback, eventName, nvlRef, interactionOptions) => {
     useEffect(() => {
-        const container = nvlRef.current?.getContainer();
+        const nvl = nvlRef.current;
         // Make sure we are not mounting interaction handlers when there is NVL setup
-        if (isNil(container)) {
+        if (isNil(nvl) || isNil(nvl.getContainer())) {
             return;
         }
-        if ((callback === true || typeof callback === 'function') && !isNil(nvlRef.current)) {
+        if (callback === true || typeof callback === 'function') {
             if (isNil(interactionRef.current)) {
-                interactionRef.current = new Interaction(nvlRef.current, interactionOptions);
+                interactionRef.current = new Interaction(nvl, interactionOptions);
             }
             if (typeof callback === 'function') {
                 interactionRef.current.updateCallback(eventName, callback);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neo4j-nvl/react",
-  "version": "0.3.8-d30e7f77",
+  "version": "0.3.8-d40957ab",
   "main": "lib/index.js",
   "homepage": "https://neo4j.com/docs/nvl/current/",
   "license": "SEE LICENSE IN 'LICENSE.txt'",
@@ -30,12 +30,12 @@
     "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/react": "^13.4.0",
     "@types/lodash": "4.14.202",
-    "@types/react": "18.2.58",
+    "@types/react": "^18.2.58",
     "babel-eslint": "^10.1.0"
   },
   "dependencies": {
-    "@neo4j-nvl/base": "0.3.8-d30e7f77",
-    "@neo4j-nvl/interaction-handlers": "0.3.8-d30e7f77",
+    "@neo4j-nvl/base": "0.3.8-d40957ab",
+    "@neo4j-nvl/interaction-handlers": "0.3.8-d40957ab",
     "lodash": "4.17.21",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"