@neo4j-nvl/interaction-handlers 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 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/).
 
+## [1.2.0] - 2026-05-27
+
+This 1.2.0 release introduces a new keyboard interaction handler and SVG support for the static image wrapper React component. It also includes several performance improvements for clustering and text/icon rendering, as well as several bug fixes.
+
+### Added
+* SVG format support in the static image wrapper.
+* Keyboard interaction handlers.
+
+### Changed
+* Boost performance of graph clustering for force directed layouts.
+* Optimize Canvas rendering performance by caching expensive operations.
+* Deprecate Cytoscape support.
+
+### Fixed
+* Fix Arabic text rendering issues to ensure characters stay connected.
+* Prevent arrow ends from bouncing by removing position rounding.
+* Fix issue where D3 layout would occasionally fail to display.
+* Fix node position loss during a restart when the device pixel ratio changes.
+* Add missing support for relationship overlay icons within the SVG renderer.
+* Fix bug where reactive zoom values were not consistently applied.
+* Correct the pinch-to-zoom speed scaling on the minimap.
+* Add safety guards against non-finite values to prevent runtime rendering errors.
+* Ensure fit targets respect `maxZoom` constraints even when omitted from `zoomOptions`.
+* Force canvas repaint when icon images finish asynchronous loading.
+
 ## [1.1.0] - 2026-02-16
 
 This 1.1.0 release introduces new rendering capabilities with the addition of a new SVG export method, alongside a new Circular Layout algorithm and touchpad gestures for zooming. It also includes performance improvements for the renderer and physics engine, as well as various fixes for the React wrappers and Minimap.

package/lib/__tests__/keyboard-interaction.test.d.ts

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

package/lib/__tests__/keyboard-interaction.test.js

@@ -0,0 +1,322 @@
+import NVL from '@neo4j-nvl/base';
+import '@testing-library/jest-dom';
+import { KeyboardInteraction } from '../interaction-handlers/keyboard-interaction';
+jest.mock('@neo4j-nvl/layout-workers');
+describe('KeyboardInteraction', () => {
+    let keyboardInteraction;
+    let myNVL;
+    const callbackMock = jest.fn();
+    beforeEach(() => {
+        myNVL = new NVL(document.createElement('div'), [
+            { id: '0', x: 100, y: 100 },
+            { id: '1', x: 200, y: 200 }
+        ], [{ id: '10', from: '0', to: '1' }], { disableWebGL: true, initialZoom: 1, layout: 'free', renderer: 'webgl' });
+        keyboardInteraction = new KeyboardInteraction(myNVL);
+    });
+    afterEach(() => {
+        keyboardInteraction.destroy();
+        myNVL.destroy();
+        callbackMock.mockReset();
+    });
+    test('sets tabindex on the container if not already present', () => {
+        expect(myNVL.getContainer().getAttribute('tabindex')).toBe('0');
+    });
+    test('does not override existing tabindex', () => {
+        keyboardInteraction.destroy();
+        const container = myNVL.getContainer();
+        container.setAttribute('tabindex', '-1');
+        keyboardInteraction = new KeyboardInteraction(myNVL);
+        expect(container.getAttribute('tabindex')).toBe('-1');
+    });
+    test('removes tabindex on destroy only if it was added by the interaction', () => {
+        keyboardInteraction.destroy();
+        expect(myNVL.getContainer().getAttribute('tabindex')).toBeNull();
+    });
+    test('does not remove tabindex on destroy if it was pre-existing', () => {
+        keyboardInteraction.destroy();
+        const container = myNVL.getContainer();
+        container.setAttribute('tabindex', '-1');
+        const interaction = new KeyboardInteraction(myNVL);
+        interaction.destroy();
+        expect(container.getAttribute('tabindex')).toBe('-1');
+    });
+    test('keydown event triggers onKeyDown callback', () => {
+        keyboardInteraction.updateCallback('onKeyDown', callbackMock);
+        const event = new KeyboardEvent('keydown', { key: 'a' });
+        myNVL.getContainer().dispatchEvent(event);
+        expect(callbackMock).toHaveBeenCalledWith(event, undefined);
+        expect(callbackMock).toHaveBeenCalledTimes(1);
+    });
+    test('keyup event triggers onKeyUp callback', () => {
+        keyboardInteraction.updateCallback('onKeyUp', callbackMock);
+        const event = new KeyboardEvent('keyup', { key: 'a' });
+        myNVL.getContainer().dispatchEvent(event);
+        expect(callbackMock).toHaveBeenCalledWith(event, undefined);
+        expect(callbackMock).toHaveBeenCalledTimes(1);
+    });
+    test('focusin event triggers onCanvasFocus callback', () => {
+        keyboardInteraction.updateCallback('onCanvasFocus', callbackMock);
+        const event = new FocusEvent('focusin');
+        myNVL.getContainer().dispatchEvent(event);
+        expect(callbackMock).toHaveBeenCalledWith(event);
+        expect(callbackMock).toHaveBeenCalledTimes(1);
+    });
+    test('focusout event triggers onCanvasBlur callback', () => {
+        keyboardInteraction.updateCallback('onCanvasBlur', callbackMock);
+        const event = new FocusEvent('focusout');
+        myNVL.getContainer().dispatchEvent(event);
+        expect(callbackMock).toHaveBeenCalledWith(event);
+        expect(callbackMock).toHaveBeenCalledTimes(1);
+    });
+    describe('automatic navigation via key mappings', () => {
+        test('Enter key enters the graph and focuses the first element', () => {
+            keyboardInteraction.updateCallback('onNodeFocus', callbackMock);
+            const event = new KeyboardEvent('keydown', { key: 'Enter', bubbles: true });
+            myNVL.getContainer().dispatchEvent(event);
+            expect(callbackMock).toHaveBeenCalledTimes(1);
+            expect(callbackMock).toHaveBeenCalledWith(expect.objectContaining({ id: '0' }), event);
+        });
+        test('Enter key does nothing when an element is already focused', () => {
+            const nodeFocusMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', nodeFocusMock);
+            const container = myNVL.getContainer();
+            // Enter the graph first
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            expect(nodeFocusMock).toHaveBeenCalledTimes(1);
+            // Press Enter again — should not navigate
+            nodeFocusMock.mockClear();
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            expect(nodeFocusMock).not.toHaveBeenCalled();
+        });
+        test('Tab does nothing when the graph has not been entered', () => {
+            keyboardInteraction.updateCallback('onNodeFocus', callbackMock);
+            myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            expect(callbackMock).not.toHaveBeenCalled();
+        });
+        test('Tab key navigates focus forward after entering the graph', () => {
+            const nodeFocusMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', nodeFocusMock);
+            const container = myNVL.getContainer();
+            // Enter the graph first
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            expect(nodeFocusMock).toHaveBeenLastCalledWith(expect.objectContaining({ id: '0' }), expect.any(KeyboardEvent));
+            // Tab to next element
+            const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true });
+            container.dispatchEvent(event);
+            expect(nodeFocusMock).toHaveBeenLastCalledWith(expect.objectContaining({ id: '1' }), event);
+        });
+        test('Shift+Tab does nothing when the graph has not been entered', () => {
+            keyboardInteraction.updateCallback('onRelationshipFocus', callbackMock);
+            myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', shiftKey: true, bubbles: true }));
+            expect(callbackMock).not.toHaveBeenCalled();
+        });
+        test('Shift+Tab navigates focus backward after entering the graph', () => {
+            const nodeFocusMock = jest.fn();
+            const relFocusMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', nodeFocusMock);
+            keyboardInteraction.updateCallback('onRelationshipFocus', relFocusMock);
+            const container = myNVL.getContainer();
+            // Enter the graph first
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            // Shift+Tab to go backward
+            const event = new KeyboardEvent('keydown', { key: 'Tab', shiftKey: true, bubbles: true });
+            container.dispatchEvent(event);
+            expect(relFocusMock).toHaveBeenCalledWith(expect.objectContaining({ id: '10' }), event);
+        });
+        test('Tab cycles through nodes and relationships', () => {
+            const nodeFocusMock = jest.fn();
+            const relFocusMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', nodeFocusMock);
+            keyboardInteraction.updateCallback('onRelationshipFocus', relFocusMock);
+            const container = myNVL.getContainer();
+            // Enter the graph: node '0'
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            expect(nodeFocusMock).toHaveBeenLastCalledWith(expect.objectContaining({ id: '0' }), expect.any(KeyboardEvent));
+            // First Tab: node '1'
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            expect(nodeFocusMock).toHaveBeenLastCalledWith(expect.objectContaining({ id: '1' }), expect.any(KeyboardEvent));
+            // Second Tab: relationship '10'
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            expect(relFocusMock).toHaveBeenCalledWith(expect.objectContaining({ id: '10' }), expect.any(KeyboardEvent));
+        });
+        test('Tab wraps around from last to first element', () => {
+            const nodeFocusMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', nodeFocusMock);
+            keyboardInteraction.updateCallback('onRelationshipFocus', jest.fn());
+            const container = myNVL.getContainer();
+            // Enter the graph, then navigate to the last element (relationship '10')
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            // Wrap around to first element
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            expect(nodeFocusMock).toHaveBeenLastCalledWith(expect.objectContaining({ id: '0' }), expect.any(KeyboardEvent));
+        });
+        test('Tab fires blur callback when moving away from a node', () => {
+            const nodeBlurMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+            keyboardInteraction.updateCallback('onNodeBlur', nodeBlurMock);
+            const container = myNVL.getContainer();
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            expect(nodeBlurMock).toHaveBeenCalledWith(expect.objectContaining({ id: '0' }), expect.any(KeyboardEvent));
+        });
+        test('Tab fires onRelationshipBlur when moving away from a relationship', () => {
+            const relBlurMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+            keyboardInteraction.updateCallback('onRelationshipFocus', jest.fn());
+            keyboardInteraction.updateCallback('onRelationshipBlur', relBlurMock);
+            const container = myNVL.getContainer();
+            // Enter the graph, then navigate to relationship
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            // Move away from relationship
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+            expect(relBlurMock).toHaveBeenCalledWith(expect.objectContaining({ id: '10' }), expect.any(KeyboardEvent));
+        });
+        test('does nothing when there are no elements', () => {
+            keyboardInteraction.destroy();
+            myNVL.destroy();
+            myNVL = new NVL(document.createElement('div'), [], [], {
+                disableWebGL: true,
+                initialZoom: 1,
+                layout: 'free',
+                renderer: 'webgl'
+            });
+            keyboardInteraction = new KeyboardInteraction(myNVL);
+            keyboardInteraction.updateCallback('onNodeFocus', callbackMock);
+            myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            expect(callbackMock).not.toHaveBeenCalled();
+        });
+        test('Escape clears element focus but keeps canvas focused', () => {
+            const nodeBlurMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+            keyboardInteraction.updateCallback('onNodeBlur', nodeBlurMock);
+            const container = myNVL.getContainer();
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+            expect(nodeBlurMock).toHaveBeenCalledWith(expect.objectContaining({ id: '0' }), expect.any(KeyboardEvent));
+            expect(keyboardInteraction.getFocused()).toBeUndefined();
+        });
+        test('Escape does nothing when nothing is focused', () => {
+            keyboardInteraction.updateCallback('onNodeBlur', callbackMock);
+            keyboardInteraction.updateCallback('onRelationshipBlur', callbackMock);
+            myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+            expect(callbackMock).not.toHaveBeenCalled();
+        });
+        test('Shift+F10 fires onContextMenu with focused element', () => {
+            const contextMenuMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+            keyboardInteraction.updateCallback('onContextMenu', contextMenuMock);
+            const container = myNVL.getContainer();
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            const event = new KeyboardEvent('keydown', { key: 'F10', shiftKey: true, bubbles: true });
+            container.dispatchEvent(event);
+            expect(contextMenuMock).toHaveBeenCalledWith(expect.objectContaining({ id: '0' }), event);
+        });
+        test('Shift+F10 fires onContextMenu with undefined when nothing is focused', () => {
+            const contextMenuMock = jest.fn();
+            keyboardInteraction.updateCallback('onContextMenu', contextMenuMock);
+            const event = new KeyboardEvent('keydown', { key: 'F10', shiftKey: true, bubbles: true });
+            myNVL.getContainer().dispatchEvent(event);
+            expect(contextMenuMock).toHaveBeenCalledWith(undefined, event);
+        });
+    });
+    describe('custom key mappings', () => {
+        test('respects custom enterGraphKey', () => {
+            keyboardInteraction.destroy();
+            keyboardInteraction = new KeyboardInteraction(myNVL, { enterGraphKey: ['Space'] });
+            keyboardInteraction.updateCallback('onNodeFocus', callbackMock);
+            // Default Enter should not enter the graph
+            myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            expect(callbackMock).not.toHaveBeenCalled();
+            // Custom key should enter the graph
+            myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Space', bubbles: true }));
+            expect(callbackMock).toHaveBeenCalledWith(expect.objectContaining({ id: '0' }), expect.any(KeyboardEvent));
+        });
+        test('respects custom navigateForwardKey', () => {
+            keyboardInteraction.destroy();
+            keyboardInteraction = new KeyboardInteraction(myNVL, { navigateForwardKey: ['ArrowDown'] });
+            keyboardInteraction.updateCallback('onNodeFocus', callbackMock);
+            const container = myNVL.getContainer();
+            // Enter the graph first
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            // Custom forward key should navigate to the next element
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }));
+            expect(callbackMock).toHaveBeenLastCalledWith(expect.objectContaining({ id: '1' }), expect.any(KeyboardEvent));
+        });
+        test('respects custom navigateBackwardKey', () => {
+            keyboardInteraction.destroy();
+            keyboardInteraction = new KeyboardInteraction(myNVL, { navigateBackwardKey: ['ArrowUp'] });
+            keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+            keyboardInteraction.updateCallback('onRelationshipFocus', callbackMock);
+            const container = myNVL.getContainer();
+            // Enter the graph first
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            // Custom backward key should navigate to the previous (last) element
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowUp', bubbles: true }));
+            expect(callbackMock).toHaveBeenCalledWith(expect.objectContaining({ id: '10' }), expect.any(KeyboardEvent));
+        });
+        test('respects custom exitGraphKey', () => {
+            keyboardInteraction.destroy();
+            keyboardInteraction = new KeyboardInteraction(myNVL, { exitGraphKey: ['q'] });
+            keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+            keyboardInteraction.updateCallback('onNodeBlur', callbackMock);
+            const container = myNVL.getContainer();
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'q', bubbles: true }));
+            expect(callbackMock).toHaveBeenCalledWith(expect.objectContaining({ id: '0' }), expect.any(KeyboardEvent));
+        });
+        test('respects custom contextMenuKey', () => {
+            keyboardInteraction.destroy();
+            keyboardInteraction = new KeyboardInteraction(myNVL, { contextMenuKey: ['Ctrl', 'm'] });
+            const contextMenuMock = jest.fn();
+            keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+            keyboardInteraction.updateCallback('onContextMenu', contextMenuMock);
+            const container = myNVL.getContainer();
+            container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+            const event = new KeyboardEvent('keydown', { key: 'm', ctrlKey: true, bubbles: true });
+            container.dispatchEvent(event);
+            expect(contextMenuMock).toHaveBeenCalledWith(expect.objectContaining({ id: '0' }), event);
+        });
+    });
+    test('getFocused returns the currently focused node', () => {
+        keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+        expect(keyboardInteraction.getFocused()).toBeUndefined();
+        myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+        expect(keyboardInteraction.getFocused()).toEqual(expect.objectContaining({ id: '0' }));
+    });
+    test('getFocused returns the currently focused relationship', () => {
+        keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+        keyboardInteraction.updateCallback('onRelationshipFocus', jest.fn());
+        const container = myNVL.getContainer();
+        container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+        container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+        container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+        expect(keyboardInteraction.getFocused()).toEqual(expect.objectContaining({ id: '10' }));
+    });
+    test('onKeyDown callback receives the currently focused element', () => {
+        keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+        keyboardInteraction.updateCallback('onKeyDown', callbackMock);
+        const container = myNVL.getContainer();
+        container.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+        const event = new KeyboardEvent('keydown', { key: 'a', bubbles: true });
+        container.dispatchEvent(event);
+        expect(callbackMock).toHaveBeenLastCalledWith(event, expect.objectContaining({ id: '0' }));
+    });
+    test('destroy removes event listeners', () => {
+        keyboardInteraction.updateCallback('onKeyDown', callbackMock);
+        keyboardInteraction.destroy();
+        const event = new KeyboardEvent('keydown', { key: 'Tab' });
+        myNVL.getContainer().dispatchEvent(event);
+        expect(callbackMock).not.toHaveBeenCalled();
+    });
+    test('destroy clears focus state', () => {
+        keyboardInteraction.updateCallback('onNodeFocus', jest.fn());
+        myNVL.getContainer().dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+        expect(keyboardInteraction.getFocused()).toBeDefined();
+        keyboardInteraction.destroy();
+        expect(keyboardInteraction.getFocused()).toBeUndefined();
+    });
+});

package/lib/__tests__/pan-interaction.test.js

@@ -2,6 +2,11 @@ import NVL from '@neo4j-nvl/base';
 import '@testing-library/jest-dom';
 import { PanInteraction } from '../interaction-handlers/pan-interaction';
 jest.mock('@neo4j-nvl/layout-workers');
+const waitForAnimationFrame = async () => {
+    await new Promise((resolve) => {
+        window.requestAnimationFrame(() => resolve());
+    });
+};
 describe('PanInteraction', () => {
     let panInteraction;
     let myNVL;
@@ -18,7 +23,7 @@ describe('PanInteraction', () => {
         myNVL.destroy();
         panCallbackMock.mockReset();
     });
-    test('performing a simple pan operation should invoke the expected callback', () => {
+    test('performing a simple pan operation should invoke the expected callback', async () => {
         panInteraction.updateCallback('onPan', panCallbackMock);
         const mouseDownEvent = new MouseEvent('mousedown', {
             clientX: 100,
@@ -36,18 +41,17 @@ describe('PanInteraction', () => {
         const container = myNVL.getContainer();
         const initialPan = myNVL.getPan();
         container.dispatchEvent(mouseDownEvent);
+        await waitForAnimationFrame();
         container.dispatchEvent(mouseMoveEvent);
+        await waitForAnimationFrame();
         container.dispatchEvent(mouseUpEvent);
-        return new Promise((resolve) => {
-            expect(panCallbackMock).toHaveBeenCalledTimes(1);
-            expect(panCallbackMock).toHaveBeenCalledWith({
-                x: initialPan.x - 20,
-                y: initialPan.y - 20
-            }, mouseMoveEvent);
-            const newPan = myNVL.getPan();
-            expect(newPan).not.toEqual(initialPan);
-            resolve();
-        });
+        expect(panCallbackMock).toHaveBeenCalledTimes(1);
+        expect(panCallbackMock).toHaveBeenCalledWith({
+            x: initialPan.x - 20,
+            y: initialPan.y - 20
+        }, mouseMoveEvent);
+        const newPan = myNVL.getPan();
+        expect(newPan).not.toEqual(initialPan);
     });
     test('panning should not work when clicking on nodes by default', () => {
         panInteraction.updateCallback('onPan', panCallbackMock);
@@ -150,7 +154,7 @@ describe('PanInteraction', () => {
             resolve();
         });
     });
-    test('when controlledPan is false, should update NVL instance normally', () => {
+    test('when controlledPan is false, should update NVL instance normally', async () => {
         panInteraction.destroy();
         myNVL.destroy();
         myNVL = new NVL(document.createElement('div'), [
@@ -172,18 +176,17 @@ describe('PanInteraction', () => {
         const mouseUpEvent = new MouseEvent('mouseup');
         const container = myNVL.getContainer();
         container.dispatchEvent(mouseDownEvent);
+        await waitForAnimationFrame();
         container.dispatchEvent(mouseMoveEvent);
+        await waitForAnimationFrame();
         container.dispatchEvent(mouseUpEvent);
-        return new Promise((resolve) => {
-            expect(myNVL.getPan()).not.toEqual(initialPan);
-            expect(myNVL.getPan()).toEqual({
-                x: initialPan.x - 20,
-                y: initialPan.y - 20
-            });
-            expect(panCallbackMock).toHaveBeenCalledTimes(1);
-            panInteractionWithUpdate.destroy();
-            resolve();
+        expect(myNVL.getPan()).not.toEqual(initialPan);
+        expect(myNVL.getPan()).toEqual({
+            x: initialPan.x - 20,
+            y: initialPan.y - 20
         });
+        expect(panCallbackMock).toHaveBeenCalledTimes(1);
+        panInteractionWithUpdate.destroy();
     });
     test('when controlledPan is true, should provide correct callback values for multiple operations', () => {
         panInteraction.destroy();

package/lib/index.d.ts

@@ -8,11 +8,13 @@ import { DrawInteraction } from './interaction-handlers/draw-interaction';
 import type { DrawInteractionCallbacks, DrawInteractionOptions } from './interaction-handlers/draw-interaction';
 import type { HoverInteractionCallbacks, HoverInteractionOptions } from './interaction-handlers/hover-interaction';
 import { HoverInteraction } from './interaction-handlers/hover-interaction';
+import type { KeyboardInteractionCallbacks, KeyboardInteractionOptions } from './interaction-handlers/keyboard-interaction';
+import { KeyboardInteraction } from './interaction-handlers/keyboard-interaction';
 import { LassoInteraction } from './interaction-handlers/lasso-interaction';
 import type { LassoInteractionCallbacks, LassoInteractionOptions } from './interaction-handlers/lasso-interaction';
 import type { PanInteractionCallbacks, PanInteractionOptions } from './interaction-handlers/pan-interaction';
 import { PanInteraction } from './interaction-handlers/pan-interaction';
 import type { ZoomInteractionCallbacks, ZoomInteractionOptions } from './interaction-handlers/zoom-interaction';
 import { ZoomInteraction } from './interaction-handlers/zoom-interaction';
-export type { BoxSelectInteractionOptions, BoxSelectInteractionCallbacks, ClickInteractionOptions, HoverInteractionOptions, HoverInteractionCallbacks, DragNodeInteractionCallbacks, ClickInteractionCallbacks, PanInteractionCallbacks, DrawInteractionCallbacks, PanInteractionOptions, ZoomInteractionCallbacks, ZoomInteractionOptions, LassoInteractionOptions, LassoInteractionCallbacks, DrawInteractionOptions };
-export { ZoomInteraction, PanInteraction, BoxSelectInteraction, ClickInteraction, HoverInteraction, DragNodeInteraction, DrawInteraction, LassoInteraction };
+export type { BoxSelectInteractionOptions, BoxSelectInteractionCallbacks, ClickInteractionOptions, HoverInteractionOptions, HoverInteractionCallbacks, DragNodeInteractionCallbacks, ClickInteractionCallbacks, KeyboardInteractionCallbacks, KeyboardInteractionOptions, PanInteractionCallbacks, DrawInteractionCallbacks, PanInteractionOptions, ZoomInteractionCallbacks, ZoomInteractionOptions, LassoInteractionOptions, LassoInteractionCallbacks, DrawInteractionOptions };
+export { ZoomInteraction, PanInteraction, BoxSelectInteraction, ClickInteraction, HoverInteraction, DragNodeInteraction, DrawInteraction, LassoInteraction, KeyboardInteraction };

package/lib/index.js

@@ -3,7 +3,8 @@ import { ClickInteraction } from './interaction-handlers/click-interaction';
 import { DragNodeInteraction } from './interaction-handlers/drag-node-interaction';
 import { DrawInteraction } from './interaction-handlers/draw-interaction';
 import { HoverInteraction } from './interaction-handlers/hover-interaction';
+import { KeyboardInteraction } from './interaction-handlers/keyboard-interaction';
 import { LassoInteraction } from './interaction-handlers/lasso-interaction';
 import { PanInteraction } from './interaction-handlers/pan-interaction';
 import { ZoomInteraction } from './interaction-handlers/zoom-interaction';
-export { ZoomInteraction, PanInteraction, BoxSelectInteraction, ClickInteraction, HoverInteraction, DragNodeInteraction, DrawInteraction, LassoInteraction };
+export { ZoomInteraction, PanInteraction, BoxSelectInteraction, ClickInteraction, HoverInteraction, DragNodeInteraction, DrawInteraction, LassoInteraction, KeyboardInteraction };

package/lib/interaction-handlers/base.d.ts

@@ -5,7 +5,7 @@ import type { NVL } from '@neo4j-nvl/base';
  * @internal
  * @hidden
  */
-declare abstract class BaseInteraction<T extends Record<string, ((...args: unknown[]) => void) | boolean>, P extends Record<string, unknown>> {
+declare abstract class BaseInteraction<P extends Record<string, unknown>> {
     private readonly nvl;
     private readonly options;
     private readonly container;
@@ -13,7 +13,7 @@ declare abstract class BaseInteraction<T extends Record<string, ((...args: unkno
      * @internal
      * @hidden
      */
-    callbackMap: Map<keyof T, T[keyof T]>;
+    callbackMap: Map<string, ((...args: unknown[]) => void) | boolean>;
     /**
      * @internal
      * @hidden
@@ -48,18 +48,18 @@ declare abstract class BaseInteraction<T extends Record<string, ((...args: unkno
      * @internal
      * @hidden
      */
-    callCallbackIfRegistered: (name: keyof T, ...args: unknown[]) => void;
+    callCallbackIfRegistered: (name: string, ...args: unknown[]) => void;
     /**
      * Add or update a callback for a given event of type.
      * @param name - The name of the event.
      * @param callback - The callback to be called when the event is triggered.
      */
-    updateCallback: (name: keyof T | string, callback: T[keyof T]) => void;
+    updateCallback: (name: string, callback: ((...args: unknown[]) => void) | boolean) => void;
     /**
      * Remove a callback for a given event of type.
      * @param name - The name of the event.
      */
-    removeCallback: (name: keyof T | string) => void;
+    removeCallback: (name: string) => void;
     /**
      * Enables or disables global text selection during a drag or pan operation.
      * @param enable - Whether to enable or disable global text selection.

package/lib/interaction-handlers/box-select-interaction.d.ts

@@ -35,7 +35,7 @@ export type BoxSelectInteractionCallbacks = {
  *
  * For examples, head to the {@link https://neo4j.com/docs/nvl/current/interaction-handlers/#_boxselectinteraction Box Select Interaction documentation page}.
  */
-export declare class BoxSelectInteraction extends BaseInteraction<BoxSelectInteractionCallbacks, BoxSelectInteractionOptions> {
+export declare class BoxSelectInteraction extends BaseInteraction<BoxSelectInteractionOptions> {
     private mousePosition;
     private startWorldPosition;
     private overlayRenderer;

package/lib/interaction-handlers/click-interaction.d.ts

@@ -78,7 +78,7 @@ export type ClickInteractionCallbacks = {
  *
  * For examples, head to the {@link https://neo4j.com/docs/nvl/current/interaction-handlers/#_clickinteraction Click Interaction documentation page}.
  */
-export declare class ClickInteraction extends BaseInteraction<ClickInteractionCallbacks, ClickInteractionOptions> {
+export declare class ClickInteraction extends BaseInteraction<ClickInteractionOptions> {
     private moved;
     private mousePosition;
     /**

package/lib/interaction-handlers/drag-node-interaction.d.ts

@@ -30,7 +30,7 @@ export type DragNodeInteractionCallbacks = {
  *
  * For examples, head to the {@link https://neo4j.com/docs/nvl/current/interaction-handlers/#_dragnodeinteraction Drag Node Interaction documentation page}.
  */
-export declare class DragNodeInteraction extends BaseInteraction<DragNodeInteractionCallbacks, Record<string, never>> {
+export declare class DragNodeInteraction extends BaseInteraction<Record<string, never>> {
     private mousePosition;
     private mouseDownNode;
     private isDragging;

package/lib/interaction-handlers/draw-interaction.d.ts

@@ -25,7 +25,7 @@ export type DrawInteractionOptions = {
  * @internal
  * @hidden
  */
-export declare class DrawInteraction extends BaseInteraction<DrawInteractionCallbacks, DrawInteractionOptions> {
+export declare class DrawInteraction extends BaseInteraction<DrawInteractionOptions> {
     private isMoved;
     private isDrawing;
     private isDraggingNode;

package/lib/interaction-handlers/hover-interaction.d.ts

@@ -29,7 +29,7 @@ export type HoverInteractionCallbacks = {
  *
  * For examples, head to the {@link https://neo4j.com/docs/nvl/current/interaction-handlers/#_hoverinteraction Hover Interaction documentation page}.
  */
-export declare class HoverInteraction extends BaseInteraction<HoverInteractionCallbacks, HoverInteractionOptions> {
+export declare class HoverInteraction extends BaseInteraction<HoverInteractionOptions> {
     private currentHoveredElementId;
     private currentHoveredElementIsNode;
     private readonly updates;

package/lib/interaction-handlers/keyboard-interaction.d.ts

@@ -0,0 +1,128 @@
+import type { NVL, Node, Relationship } from '@neo4j-nvl/base';
+import { BaseInteraction } from './base';
+/**
+ * Options for the keyboard interaction handler.
+ * Allows configuring which keys trigger specific navigation actions.
+ * Each key combo is an array of strings: the last element is the primary key (`event.key`),
+ * and any preceding elements are modifier keys (`'Shift'`, `'Ctrl'`, `'Alt'`, `'Meta'`).
+ *
+ * @example
+ * ```ts
+ * import { KeyboardInteractionOptions } from '@neo4j-nvl/interaction-handlers'
+ *
+ * const options: KeyboardInteractionOptions = {
+ *   navigateForwardKey: ['Tab'],
+ *   contextMenuKey: ['Shift', 'F10']
+ * }
+ * ```
+ */
+export type KeyboardInteractionOptions = {
+    /** Key combo for entering the graph and focusing the first element. Default: `['Enter']` */
+    enterGraphKey?: string[];
+    /** Key combo for navigating focus to the next element. Default: `['Tab']` */
+    navigateForwardKey?: string[];
+    /** Key combo for navigating focus to the previous element. Default: `['Shift', 'Tab']` */
+    navigateBackwardKey?: string[];
+    /** Key combo for exiting the graph (blur focused element and container). Default: `['Escape']` */
+    exitGraphKey?: string[];
+    /** Key combo for opening the context menu on the focused element. Default: `['Shift', 'F10']` */
+    contextMenuKey?: string[];
+};
+/**
+ * Callbacks for the keyboard interaction handler.
+ */
+export type KeyboardInteractionCallbacks = {
+    /**
+     * Called when a key is pressed while the NVL container is focused.
+     * Fires for all key events, including those handled by the built-in navigation.
+     * @param event - The original keyboard event.
+     * @param focusedElement - The currently focused node or relationship, if any.
+     */
+    onKeyDown?: ((event: KeyboardEvent, focusedElement?: Node | Relationship) => void) | boolean;
+    /**
+     * Called when a key is released while the NVL container is focused
+     * @param event - The original keyboard event.
+     * @param focusedElement - The currently focused node or relationship, if any.
+     */
+    onKeyUp?: ((event: KeyboardEvent, focusedElement?: Node | Relationship) => void) | boolean;
+    /**
+     * Called when a node receives focus (via keyboard navigation)
+     * @param node - The node that received focus.
+     * @param event - The original keyboard event that triggered the focus change.
+     */
+    onNodeFocus?: ((node: Node, event: KeyboardEvent) => void) | boolean;
+    /**
+     * Called when a node loses focus (via keyboard navigation)
+     * @param node - The node that lost focus.
+     * @param event - The original keyboard event that triggered the focus change.
+     */
+    onNodeBlur?: ((node: Node, event: KeyboardEvent) => void) | boolean;
+    /**
+     * Called when a relationship receives focus (via keyboard navigation)
+     * @param relationship - The relationship that received focus.
+     * @param event - The original keyboard event that triggered the focus change.
+     */
+    onRelationshipFocus?: ((relationship: Relationship, event: KeyboardEvent) => void) | boolean;
+    /**
+     * Called when a relationship loses focus (via keyboard navigation)
+     * @param relationship - The relationship that lost focus.
+     * @param event - The original keyboard event that triggered the focus change.
+     */
+    onRelationshipBlur?: ((relationship: Relationship, event: KeyboardEvent) => void) | boolean;
+    /**
+     * Called when the NVL canvas container receives DOM focus
+     * @param event - The original focus event.
+     */
+    onCanvasFocus?: ((event: FocusEvent) => void) | boolean;
+    /**
+     * Called when the NVL canvas container loses DOM focus
+     * @param event - The original focus event.
+     */
+    onCanvasBlur?: ((event: FocusEvent) => void) | boolean;
+    /**
+     * Called when the context menu key is pressed while the NVL container is focused.
+     * @param element - The focused node or relationship, or undefined if the canvas itself is focused.
+     * @param event - The original keyboard event.
+     */
+    onContextMenu?: ((element: Node | Relationship | undefined, event: KeyboardEvent) => void) | boolean;
+};
+/**
+ * Opinionated interaction handler for keyboard-driven focus navigation
+ * through graph elements (nodes and relationships).
+ *
+ * By default, Tab / Shift+Tab cycle focus through elements, Escape exits the
+ * graph, and Shift+F10 call the `onContextMenu` callback with the focused element.
+ * All keys can be reconfigured via {@link KeyboardInteractionOptions}.
+ *
+ * Callbacks are fired for focus/blur transitions and context-menu activation,
+ * following the same one-way data-flow pattern as the other interaction handlers.
+ */
+export declare class KeyboardInteraction extends BaseInteraction<KeyboardInteractionOptions> {
+    private focusedElementId;
+    private focusedElementIsNode;
+    private focusableElements;
+    private addedTabindex;
+    private resolvedOptions;
+    /**
+     * Creates a new keyboard interaction handler.
+     * @param nvl - The NVL instance to attach the interaction handler to.
+     * @param options - Options for the keyboard interaction handler.
+     */
+    constructor(nvl: NVL, options?: KeyboardInteractionOptions);
+    private buildFocusableElements;
+    /**
+     * Returns the currently focused element, if any.
+     */
+    getFocused(): Node | Relationship | undefined;
+    private handleFocusIn;
+    private handleFocusOut;
+    private handleKeyDown;
+    private handleKeyUp;
+    private navigateFocus;
+    private setFocus;
+    private clearFocus;
+    /**
+     * Removes all related event listeners from the container.
+     */
+    destroy(): void;
+}

package/lib/interaction-handlers/keyboard-interaction.js

@@ -0,0 +1,189 @@
+import { BaseInteraction } from './base';
+const DEFAULT_OPTIONS = {
+    enterGraphKey: ['Enter'],
+    navigateForwardKey: ['Tab'],
+    navigateBackwardKey: ['Shift', 'Tab'],
+    exitGraphKey: ['Escape'],
+    contextMenuKey: ['Shift', 'F10']
+};
+/**
+ * Checks whether a keyboard event matches a key combo array.
+ * The last element is the primary key (`event.key`), preceding elements are modifiers.
+ * Examples: `['Tab']`, `['Shift', 'Tab']`, `['Shift', 'F10']`
+ */
+const matchesKeyCombo = (event, keyCombo) => {
+    const key = keyCombo[keyCombo.length - 1];
+    const requireShift = keyCombo.includes('Shift');
+    const requireCtrl = keyCombo.includes('Ctrl');
+    const requireAlt = keyCombo.includes('Alt');
+    const requireMeta = keyCombo.includes('Meta');
+    return (event.key === key &&
+        event.shiftKey === requireShift &&
+        event.ctrlKey === requireCtrl &&
+        event.altKey === requireAlt &&
+        event.metaKey === requireMeta);
+};
+/**
+ * Opinionated interaction handler for keyboard-driven focus navigation
+ * through graph elements (nodes and relationships).
+ *
+ * By default, Tab / Shift+Tab cycle focus through elements, Escape exits the
+ * graph, and Shift+F10 call the `onContextMenu` callback with the focused element.
+ * All keys can be reconfigured via {@link KeyboardInteractionOptions}.
+ *
+ * Callbacks are fired for focus/blur transitions and context-menu activation,
+ * following the same one-way data-flow pattern as the other interaction handlers.
+ */
+export class KeyboardInteraction extends BaseInteraction {
+    focusedElementId = undefined;
+    focusedElementIsNode = undefined;
+    focusableElements = [];
+    addedTabindex = false;
+    resolvedOptions;
+    /**
+     * Creates a new keyboard interaction handler.
+     * @param nvl - The NVL instance to attach the interaction handler to.
+     * @param options - Options for the keyboard interaction handler.
+     */
+    constructor(nvl, options = {}) {
+        super(nvl, options);
+        this.resolvedOptions = { ...DEFAULT_OPTIONS, ...options };
+        // Ensure the container is focusable for keyboard events
+        const tabindex = this.containerInstance.getAttribute('tabindex');
+        if (tabindex === null || tabindex === '') {
+            this.containerInstance.setAttribute('tabindex', '0');
+            this.addedTabindex = true;
+        }
+        this.addEventListener('keydown', this.handleKeyDown);
+        this.addEventListener('keyup', this.handleKeyUp);
+        this.addEventListener('focusin', this.handleFocusIn);
+        this.addEventListener('focusout', this.handleFocusOut);
+    }
+    buildFocusableElements() {
+        const nodes = this.nvlInstance.getNodes();
+        const relationships = this.nvlInstance.getRelationships();
+        this.focusableElements = [
+            ...nodes.map((node) => ({ id: node.id, isNode: true })),
+            ...relationships.map((rel) => ({ id: rel.id, isNode: false }))
+        ];
+    }
+    /**
+     * Returns the currently focused element, if any.
+     */
+    getFocused() {
+        if (this.focusedElementId === undefined) {
+            return undefined;
+        }
+        if (this.focusedElementIsNode === true) {
+            return this.nvlInstance.getNodes().find((n) => n.id === this.focusedElementId);
+        }
+        return this.nvlInstance.getRelationships().find((r) => r.id === this.focusedElementId);
+    }
+    handleFocusIn = (event) => {
+        this.callCallbackIfRegistered('onCanvasFocus', event);
+    };
+    handleFocusOut = (event) => {
+        this.callCallbackIfRegistered('onCanvasBlur', event);
+    };
+    handleKeyDown = (event) => {
+        const focusedElement = this.getFocused();
+        this.callCallbackIfRegistered('onKeyDown', event, focusedElement);
+        const { enterGraphKey, navigateForwardKey, navigateBackwardKey, exitGraphKey, contextMenuKey } = this.resolvedOptions;
+        if (matchesKeyCombo(event, enterGraphKey)) {
+            if (focusedElement === undefined) {
+                event.preventDefault();
+                this.navigateFocus(1, event);
+            }
+        }
+        else if (matchesKeyCombo(event, navigateForwardKey)) {
+            if (focusedElement !== undefined) {
+                event.preventDefault();
+                this.navigateFocus(1, event);
+            }
+        }
+        else if (matchesKeyCombo(event, navigateBackwardKey)) {
+            if (focusedElement !== undefined) {
+                event.preventDefault();
+                this.navigateFocus(-1, event);
+            }
+        }
+        else if (matchesKeyCombo(event, exitGraphKey)) {
+            if (focusedElement !== undefined) {
+                event.preventDefault();
+                this.clearFocus(event);
+            }
+        }
+        else if (matchesKeyCombo(event, contextMenuKey)) {
+            event.preventDefault();
+            this.callCallbackIfRegistered('onContextMenu', focusedElement, event);
+        }
+    };
+    handleKeyUp = (event) => {
+        const focusedElement = this.getFocused();
+        this.callCallbackIfRegistered('onKeyUp', event, focusedElement);
+    };
+    navigateFocus(direction, event) {
+        this.buildFocusableElements();
+        if (this.focusableElements.length === 0) {
+            return;
+        }
+        const currentIndex = this.focusedElementId !== undefined
+            ? this.focusableElements.findIndex((el) => el.id === this.focusedElementId && el.isNode === this.focusedElementIsNode)
+            : -1;
+        let nextIndex;
+        if (currentIndex === -1) {
+            nextIndex = direction === 1 ? 0 : this.focusableElements.length - 1;
+        }
+        else {
+            nextIndex = (currentIndex + direction + this.focusableElements.length) % this.focusableElements.length;
+        }
+        const nextElement = this.focusableElements[nextIndex];
+        if (nextElement) {
+            this.setFocus(nextElement.id, nextElement.isNode, event);
+        }
+    }
+    setFocus(elementId, isNode, event) {
+        this.clearFocus(event);
+        // Update focus state
+        this.focusedElementId = elementId;
+        this.focusedElementIsNode = isNode;
+        // Notify about the newly focused element
+        const newElement = this.getFocused();
+        if (newElement !== undefined) {
+            if (isNode) {
+                this.callCallbackIfRegistered('onNodeFocus', newElement, event);
+            }
+            else {
+                this.callCallbackIfRegistered('onRelationshipFocus', newElement, event);
+            }
+        }
+    }
+    clearFocus(event) {
+        const previousElement = this.getFocused();
+        if (previousElement !== undefined) {
+            if (this.focusedElementIsNode === true) {
+                this.callCallbackIfRegistered('onNodeBlur', previousElement, event);
+            }
+            else {
+                this.callCallbackIfRegistered('onRelationshipBlur', previousElement, event);
+            }
+        }
+        this.focusedElementId = undefined;
+        this.focusedElementIsNode = undefined;
+    }
+    /**
+     * Removes all related event listeners from the container.
+     */
+    destroy() {
+        this.removeEventListener('keydown', this.handleKeyDown);
+        this.removeEventListener('keyup', this.handleKeyUp);
+        this.removeEventListener('focusin', this.handleFocusIn);
+        this.removeEventListener('focusout', this.handleFocusOut);
+        if (this.addedTabindex) {
+            this.containerInstance.removeAttribute('tabindex');
+        }
+        this.focusedElementId = undefined;
+        this.focusedElementIsNode = undefined;
+        this.focusableElements = [];
+    }
+}

package/lib/interaction-handlers/lasso-interaction.d.ts

@@ -58,7 +58,7 @@ export declare const checkPointInside: (x: number, y: number, vs: Point[]) => bo
  *
  * For examples, head to the {@link https://neo4j.com/docs/nvl/current/interaction-handlers/#_lassointeraction Lasso Interaction documentation page}.
  */
-export declare class LassoInteraction extends BaseInteraction<LassoInteractionCallbacks, LassoInteractionOptions> {
+export declare class LassoInteraction extends BaseInteraction<LassoInteractionOptions> {
     private active;
     private points;
     private overlayRenderer;

package/lib/interaction-handlers/pan-interaction.d.ts

@@ -36,7 +36,7 @@ export type PanInteractionCallbacks = {
  *
  * For examples, head to the {@link https://neo4j.com/docs/nvl/current/interaction-handlers/#_paninteraction Pan Interaction documentation page}.
  */
-export declare class PanInteraction extends BaseInteraction<PanInteractionCallbacks, PanInteractionOptions> {
+export declare class PanInteraction extends BaseInteraction<PanInteractionOptions> {
     private initialMousePosition;
     private initialPan;
     private targets;

package/lib/interaction-handlers/zoom-interaction.d.ts

@@ -39,7 +39,7 @@ export type ZoomInteractionCallbacks = {
  *
  * For examples, head to the {@link https://neo4j.com/docs/nvl/current/interaction-handlers/#_zoominteraction Zoom Interaction documentation page}.
  */
-export declare class ZoomInteraction extends BaseInteraction<ZoomInteractionCallbacks, ZoomInteractionOptions> {
+export declare class ZoomInteraction extends BaseInteraction<ZoomInteractionOptions> {
     private zoomLimits;
     /**
      * Creates a new instance of the zoom interaction handler.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neo4j-nvl/interaction-handlers",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "license": "SEE LICENSE IN 'LICENSE.txt'",
   "homepage": "https://neo4j.com/docs/nvl/current/",
   "description": "Interaction handlers for the Neo4j Visualization Library",
@@ -27,9 +27,9 @@
     "eslint": "yarn global:eslint ./src/"
   },
   "dependencies": {
-    "@neo4j-nvl/base": "1.1.0",
+    "@neo4j-nvl/base": "1.2.0",
     "concaveman": "1.2.1",
-    "lodash": "4.17.23"
+    "lodash": "4.18.1"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "5.17.0",