type almost fully working

Author: thebestnom

__mocks__/neo4j-driver.ts

@@ -3,7 +3,7 @@ import { ObservablePromise } from '../__tests__/testUtils';
 const Neo4j: typeof Neo4jType = jest.requireActual('neo4j-driver');
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export const mockSessionRun: jest.Mock<ObservablePromise<any>, [cypher: string, b: Record<string, any>]> = jest.fn((..._) => {
+export const mockSessionRun: jest.Mock<ObservablePromise<unknown>, [cypher: string, b: Record<string, unknown>]> = jest.fn((..._) => {
 	const observablePromise: Partial<ObservablePromise<void>> = Promise.resolve();
 	// eslint-disable-next-line @typescript-eslint/no-empty-function
 	observablePromise.subscribe = jest.fn(() => {});

__tests__/neovis.tests.ts

@@ -1,9 +1,7 @@
 import Neo4j, * as Neo4jMockImport from 'neo4j-driver';
 import Neovis, {
-	NEOVIS_DEFAULT_CONFIG,
-	NEOVIS_ADVANCED_CONFIG,
 	migrateFromOldConfig,
-	NeovisConfig, NonFlatNeovisConfig, OldNeoVisConfig
+	OldNeoVisConfig
 } from '../src/neovis';
 import { NeoVisEvents } from '../src/events';
 import * as testUtils from './testUtils';
@@ -12,6 +10,7 @@ import * as testUtils from './testUtils';
 import type * as Neo4jMockType from '../__mocks__/neo4j-driver';
 import type NeoVis from '../src/neovis';
 import type VisNetwork from 'vis-network';
+import { NEOVIS_ADVANCED_CONFIG, NEOVIS_DEFAULT_CONFIG, NeovisConfig, NonFlatNeovisConfig } from '../src/types';
 
 jest.mock('neo4j-driver');
 
@@ -390,15 +389,15 @@ describe('Neovis', () => {
 	// TODO: After upgrading to merge config, type casting is failing due to not able to detect target type. A proper way
 	// 			either let the user to define type casting or do it automaticlly need to be implemented.
 	describe('neovis type casting test', () => {
-		const intProperty = 'intProperity';
+		const intProperty = 'intProperty';
 		const intPropertyValue = 40;
 
 		it('should merge property name type to vis.js config properly', async () => {
-			const config = {
+			const config: NeovisConfig = {
 				container_id: container_id,
 				labels: {
 					[label1]: {
-						'label': intProperty
+
 					}
 				},
 				initial_cypher: initial_cypher
@@ -413,7 +412,9 @@ describe('Neovis', () => {
 			neovis.render();
 			await testUtils.neovisRenderDonePromise(neovis);
 			expect(Neo4jMock.mockSessionRun).toHaveBeenCalledTimes(1);
-			expect(neovis.nodes.get(1)).toHaveProperty('label', intPropertyValue);
+			expect(neovis.nodes.get(1)).toHaveProperty('font');
+			expect(neovis.nodes.get(1).font).toHaveProperty('size', intPropertyValue);
+			expect(neovis.nodes.get(1).font).toHaveProperty('color', intPropertyValue);
 		});
 
 		it('should merge static type to vis.js config properly', async () => {

__tests__/testUtils.ts

@@ -1,6 +1,6 @@
 import type * as Neo4jType from 'neo4j-driver';
 import * as Neo4jMockImport from 'neo4j-driver';
-import { NeoVisEvents } from '../src/events';
+import { EventFunctionTypes, NeoVisEvents } from '../src/events';
 import * as Neo4jCore from 'neo4j-driver-core';
 
 // eslint-disable-next-line jest/no-mocks-import
@@ -18,11 +18,11 @@ export function clearIdCounter(): void {
 	counter = 1;
 }
 
-export function makeNode(labels: string[], properties: any = {}): Neo4jCore.Node<number> {
+export function makeNode(labels: string[], properties: unknown = {}): Neo4jCore.Node<number> {
 	return new Neo4jCore.Node(counter++, labels, properties);
 }
 
-export function makeRelationship(type: string, startNode: Neo4jCore.Node<number>, endNode: Neo4jCore.Node<number>, properties: any = {}): Neo4jCore.Relationship<number> {
+export function makeRelationship(type: string, startNode: Neo4jCore.Node<number>, endNode: Neo4jCore.Node<number>, properties: unknown = {}): Neo4jCore.Relationship<number> {
 	return new Neo4jCore.Relationship(counter++, startNode.identity, endNode.identity, type, properties);
 }
 
@@ -38,7 +38,7 @@ export function makePathFromNodes(nodes: Neo4jType.Node<number>[], relationshipT
 	return new Neo4jCore.Path(nodes[0], nodes[nodes.length - 1], pathSegments);
 }
 
-export function makeRecord(parameters: any[]): Neo4jCore.Record {
+export function makeRecord<T>(parameters: T[]): Neo4jCore.Record<{ [key: string] : unknown }> {
 	const recordKeys = parameters.map((_, index) => index.toString());
 	return new Neo4jCore.Record(recordKeys, parameters);
 }
@@ -57,36 +57,36 @@ export function assertEdges(neovis: NeoVis, edges: Neo4jType.Relationship<number
 	});
 }
 
-export function mockNormalRunSubscribe(records: Neo4jType.Record<any>[] = []): void {
+export function mockNormalRunSubscribe(records: Neo4jType.Record<{ [key: string]: unknown }>[] = []): void {
 	Neo4jMock.mockSessionRun.mockImplementation(() => {
-		const observablePromise: Partial<ObservablePromise<{ records: Neo4jType.Record<any>[] }>> = Promise.resolve({ records });
+		const observablePromise: Partial<ObservablePromise<{ records: Neo4jType.Record<{ [key: string]: unknown }>[] }>> = Promise.resolve({ records });
 		observablePromise.subscribe = ({ onNext, onCompleted }) => {
 			records.forEach(onNext);
 			onCompleted();
 		};
-		return observablePromise as ObservablePromise<{ records: Neo4jType.Record<any>[] }>;
+		return observablePromise as ObservablePromise<{ records: Neo4jType.Record<unknown>[] }>;
 	});
 }
 
-export function mockFullRunSubscribe(cypherIdsAndAnswers: Record<string, { default?: Neo4jType.Record<any>[], [id: number]: Neo4jType.Record<any>[] } >): void {
-	Neo4jMock.mockSessionRun.mockImplementation((cypher: string, parameters: Record<string, any>) => {
+export function mockFullRunSubscribe(cypherIdsAndAnswers: Record<string, { default?: Neo4jType.Record<{ [key: string]: unknown }>[], [id: number]: Neo4jType.Record<{ [key: string]: unknown }>[] } >): void {
+	Neo4jMock.mockSessionRun.mockImplementation((cypher: string, parameters: { id: number}) => {
 		if (!cypherIdsAndAnswers[cypher]) {
 			throw new Error(`the cypher '${cypher}' was not expected`);
 		}
 		if (!cypherIdsAndAnswers[cypher].default && !cypherIdsAndAnswers[cypher][parameters.id]) {
 			throw new Error(`the id '${parameters.id}' was not expected for cypher ${cypher}`);
 		}
 		const records = cypherIdsAndAnswers[cypher].default || cypherIdsAndAnswers[cypher][parameters.id];
-		const observablePromise: Partial<ObservablePromise<{ records: Neo4jType.Record<any>[] }>> = Promise.resolve({ records });
+		const observablePromise: Partial<ObservablePromise<{ records: Neo4jType.Record<{ [key: string]: unknown }>[] }>> = Promise.resolve({ records });
 		observablePromise.subscribe = ({ onNext, onCompleted }) => {
 			records.forEach(onNext);
 			onCompleted();
 		};
-		return observablePromise as ObservablePromise<{ records: Neo4jType.Record<any>[] }>;
+		return observablePromise as ObservablePromise<{ records: Neo4jType.Record<unknown>[] }>;
 	});
 }
 
 
-export function neovisRenderDonePromise(neovis: NeoVis): Promise<void> {
+export function neovisRenderDonePromise(neovis: NeoVis): Promise<Parameters<EventFunctionTypes[NeoVisEvents.CompletionEvent]>[0]> {
 	return new Promise(res => neovis.registerOnEvent(NeoVisEvents.CompletionEvent, res));
 }

dist/events.d.ts

@@ -1,22 +1,39 @@
+import { Edge, Node } from './types';
 export declare enum NeoVisEvents {
     CompletionEvent = "completed",
     ClickNodeEvent = "clickNode",
     ClickEdgeEvent = "clickEdge",
     ErrorEvent = "error"
 }
+export interface EventFunctionTypes {
+    [NeoVisEvents.CompletionEvent]: (event: {
+        recordCount: number;
+    }) => void;
+    [NeoVisEvents.ClickNodeEvent]: (event: {
+        nodeId: number;
+        node: Node;
+    }) => void;
+    [NeoVisEvents.ClickEdgeEvent]: (event: {
+        edgeId: number;
+        edge: Edge;
+    }) => void;
+    [NeoVisEvents.ErrorEvent]: (event: {
+        error: Error;
+    }) => void;
+}
 export declare class EventController {
     private readonly _handlers;
     constructor();
     /**
      *
-     * @param {string} eventType - Type of the event to be handled
-     * @param {callback} handler - Handler to manage the event
+     * @param eventType - Type of the event to be handled
+     * @param handler - Handler to manage the event
      */
-    register(eventType: NeoVisEvents, handler: Function): void;
+    register<T extends NeoVisEvents>(eventType: T, handler: EventFunctionTypes[T]): void;
     /**
      *
      * @param {string} eventType - Type of the event generated
      * @param {any} values - Values associated to the event
      */
-    generateEvent(eventType: NeoVisEvents, values: any): void;
+    generateEvent<T extends NeoVisEvents>(eventType: T, values: Parameters<EventFunctionTypes[T]>[0]): void;
 }