@deck.gl-community/graph-layers 9.1.1 → 9.2.0-beta.2

package/src/layouts/d3-force/d3-force-layout.ts

@@ -2,11 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GraphLayout, GraphLayoutOptions} from '../../core/graph-layout';
+import {GraphLayout, GraphLayoutProps} from '../../core/graph-layout';
+import {log} from '../../utils/log';
 
-import {EDGE_TYPE} from '../../core/constants';
-
-export type D3ForceLayoutOptions = GraphLayoutOptions & {
+export type D3ForceLayoutOptions = GraphLayoutProps & {
   alpha?: number;
   resumeAlpha?: number;
   nBodyStrength?: number;
@@ -16,7 +15,7 @@ export type D3ForceLayoutOptions = GraphLayoutOptions & {
 };
 
 export class D3ForceLayout extends GraphLayout<D3ForceLayoutOptions> {
-  static defaultOptions: Required<D3ForceLayoutOptions> = {
+  static defaultProps: Required<D3ForceLayoutOptions> = {
     alpha: 0.3,
     resumeAlpha: 0.1,
     nBodyStrength: -900,
@@ -34,7 +33,7 @@ export class D3ForceLayout extends GraphLayout<D3ForceLayoutOptions> {
     super(options);
 
     this._options = {
-      ...D3ForceLayout.defaultOptions,
+      ...D3ForceLayout.defaultProps,
       ...options
     };
   }
@@ -84,6 +83,7 @@ export class D3ForceLayout extends GraphLayout<D3ForceLayoutOptions> {
     });
 
     this._worker.onmessage = (event) => {
+      log.log(0, 'D3ForceLayout: worker message', event.data?.type, event.data);
       if (event.data.type !== 'end') {
         return;
       }
@@ -106,25 +106,39 @@ export class D3ForceLayout extends GraphLayout<D3ForceLayoutOptions> {
   }
 
   stop() {
-    this._worker.terminate();
+    if (this._worker) {
+      this._worker.terminate();
+      this._worker = null;
+    }
   }
 
   getEdgePosition = (edge) => {
     const sourceNode = this._graph.findNode(edge.getSourceNodeId());
     const targetNode = this._graph.findNode(edge.getTargetNodeId());
-    if (!this.getNodePosition(sourceNode) || !this.getNodePosition(targetNode)) {
+    if (!sourceNode || !targetNode) {
+      return null;
+    }
+
+    const sourcePosition = this.getNodePosition(sourceNode);
+    const targetPosition = this.getNodePosition(targetNode);
+
+    if (!sourcePosition || !targetPosition) {
       return null;
     }
 
     return {
-      type: EDGE_TYPE.LINE,
-      sourcePosition: this.getNodePosition(sourceNode),
-      targetPosition: this.getNodePosition(targetNode),
+      type: 'line',
+      sourcePosition,
+      targetPosition,
       controlPoints: []
     };
   };
 
   getNodePosition = (node) => {
+    if (!node) {
+      return null;
+    }
+
     const d3Node = this._positionsByNodeId.get(node.id);
     if (d3Node) {
       return d3Node.coordinates;
@@ -152,4 +166,12 @@ export class D3ForceLayout extends GraphLayout<D3ForceLayoutOptions> {
     d3Node.fx = null;
     d3Node.fy = null;
   };
+
+  protected override _updateBounds(): void {
+    const positions = Array.from(
+      this._positionsByNodeId.values(),
+      (data) => data?.coordinates as [number, number] | null | undefined
+    );
+    this._bounds = this._calculateBounds(positions);
+  }
 }

package/src/layouts/experimental/force-multi-graph-layout.ts

@@ -2,21 +2,20 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GraphLayout, GraphLayoutOptions} from '../../core/graph-layout';
+import {GraphLayout, GraphLayoutProps} from '../../core/graph-layout';
 import {Node} from '../../graph/node';
-import {EDGE_TYPE} from '../../core/constants';
 import {Graph} from '../../graph/graph';
 import * as d3 from 'd3-force';
 
-export type ForceMultiGraphLayoutOptions = GraphLayoutOptions & {
+export type ForceMultiGraphLayoutProps = GraphLayoutProps & {
   alpha?: number;
   nBodyStrength?: number;
   nBodyDistanceMin?: number;
   nBodyDistanceMax?: number;
 };
 
-export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOptions> {
-  static defaultOptions = {
+export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutProps> {
+  static defaultProps = {
     alpha: 3,
     nBodyStrength: -1200,
     nBodyDistanceMin: 100,
@@ -33,10 +32,10 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
   _edgeMap = {};
   _simulator;
 
-  constructor(options: ForceMultiGraphLayoutOptions = {}) {
+  constructor(options: ForceMultiGraphLayoutProps = {}) {
     super(options);
     this._options = {
-      ...ForceMultiGraphLayout.defaultOptions,
+      ...ForceMultiGraphLayout.defaultProps,
       ...options
     };
   }
@@ -68,6 +67,7 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
         'edge',
         d3
           .forceLink(g.edges)
+          // @ts-ignore TODO id not defined?
           .id((n) => n.id)
           .strength(this._strength)
       )
@@ -98,6 +98,8 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
     this._simulator.stop();
   }
 
+  update(): void {}
+
   updateGraph(graph) {
     this._graph = graph;
 
@@ -138,7 +140,7 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
       if (betweenEdges.length === 1) {
         // do nothing, this is a real edge
         const newD3Edge = {
-          type: EDGE_TYPE.LINE,
+          type: 'line',
           id: firstEdge.getId(),
           source: newNodeMap[firstEdge.getSourceNodeId()],
           target: newNodeMap[firstEdge.getTargetNodeId()],
@@ -151,7 +153,7 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
 
       // else reduce to one virtual edge
       const newD3Edge = {
-        type: EDGE_TYPE.LINE,
+        type: 'line',
         id: pairId,
         source: newNodeMap[firstEdge.getSourceNodeId()],
         target: newNodeMap[firstEdge.getTargetNodeId()],
@@ -163,7 +165,7 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
 
       betweenEdges.forEach((e, idx) => {
         newEdgeMap[e.id] = {
-          type: EDGE_TYPE.SPLINE_CURVE,
+          type: 'spline-curve',
           id: e.id,
           source: newNodeMap[e.getSourceNodeId()],
           target: newNodeMap[e.getTargetNodeId()],
@@ -194,7 +196,7 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
     if (d3Edge) {
       if (!d3Edge.isVirtual) {
         return {
-          type: EDGE_TYPE.LINE,
+          type: 'line',
           sourcePosition: [d3Edge.source.x, d3Edge.source.y],
           targetPosition: [d3Edge.target.x, d3Edge.target.y],
           controlPoints: []
@@ -222,7 +224,7 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
         (symmetricShape ? Math.floor(index / 2 + 1) : Math.ceil(index / 2));
       const controlPoint = computeControlPoint(sourcePosition, targetPosition, direction, offset);
       return {
-        type: EDGE_TYPE.SPLINE_CURVE,
+        type: 'spline-curve',
         sourcePosition,
         targetPosition,
         controlPoints: [controlPoint]
@@ -230,7 +232,7 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
     }
     // default value
     return {
-      type: EDGE_TYPE.LINE,
+      type: 'line',
       sourcePosition: [0, 0],
       targetPosition: [0, 0],
       controlPoints: []
@@ -244,6 +246,13 @@ export class ForceMultiGraphLayout extends GraphLayout<ForceMultiGraphLayoutOpti
     this._onLayoutChange();
     this._onLayoutDone();
   };
+
+  protected override _updateBounds(): void {
+    const positions = Object.values(this._nodeMap ?? {}).map((node) =>
+      this._normalizePosition(node)
+    );
+    this._bounds = this._calculateBounds(positions);
+  }
 }
 
 /**

package/src/layouts/experimental/hive-plot-layout.ts

@@ -2,23 +2,22 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GraphLayout, GraphLayoutOptions} from '../../core/graph-layout';
+import {GraphLayout, GraphLayoutProps} from '../../core/graph-layout';
 import {Node} from '../../graph/node';
-import {EDGE_TYPE} from '../../core/constants';
 import {Graph} from '../../graph/graph';
 
-export type HivePlotLayoutOptions = GraphLayoutOptions & {
+export type HivePlotLayoutProps = GraphLayoutProps & {
   innerRadius?: number;
   outerRadius?: number;
   getNodeAxis?: (node: Node) => any;
 };
 
-export class HivePlotLayout extends GraphLayout<HivePlotLayoutOptions> {
-  static defaultOptions = {
+export class HivePlotLayout extends GraphLayout<HivePlotLayoutProps> {
+  static defaultProps = {
     innerRadius: 100,
     outerRadius: 500,
     getNodeAxis: (node: Node) => node.getPropertyValue('group')
-  } as const satisfies Readonly<Required<HivePlotLayoutOptions>>;
+  } as const satisfies Readonly<Required<HivePlotLayoutProps>>;
 
   _name = 'HivePlot';
   _graph: Graph;
@@ -27,10 +26,10 @@ export class HivePlotLayout extends GraphLayout<HivePlotLayoutOptions> {
   _nodeMap = {};
   _nodePositionMap = {};
 
-  constructor(options: HivePlotLayoutOptions = {}) {
+  constructor(options: HivePlotLayoutProps = {}) {
     super(options);
     this._options = {
-      ...HivePlotLayout.defaultOptions,
+      ...HivePlotLayout.defaultProps,
       ...options
     };
   }
@@ -98,6 +97,12 @@ export class HivePlotLayout extends GraphLayout<HivePlotLayoutOptions> {
     this._onLayoutDone();
   }
 
+  stop() {}
+
+  update() {}
+
+  resume() {}
+
   getNodePosition = (node) => this._nodePositionMap[node.getId()];
 
   getEdgePosition = (edge) => {
@@ -116,7 +121,7 @@ export class HivePlotLayout extends GraphLayout<HivePlotLayoutOptions> {
 
     if (sourceNodeAxis === targetNodeAxis) {
       return {
-        type: EDGE_TYPE.LINE,
+        type: 'line',
         sourcePosition,
         targetPosition,
         controlPoints: []
@@ -132,7 +137,7 @@ export class HivePlotLayout extends GraphLayout<HivePlotLayoutOptions> {
     });
 
     return {
-      type: EDGE_TYPE.SPLINE_CURVE,
+      type: 'spline-curve',
       sourcePosition,
       targetPosition,
       controlPoints: [controlPoint]
@@ -144,6 +149,13 @@ export class HivePlotLayout extends GraphLayout<HivePlotLayoutOptions> {
     this._onLayoutChange();
     this._onLayoutDone();
   };
+
+  protected override _updateBounds(): void {
+    const positions = Object.values(this._nodePositionMap ?? {}).map((position) =>
+      this._normalizePosition(position)
+    );
+    this._bounds = this._calculateBounds(positions);
+  }
 }
 
 function computeControlPoint({

package/src/layouts/experimental/radial-layout.ts

@@ -2,11 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GraphLayout, GraphLayoutOptions} from '../../core/graph-layout';
-import {EDGE_TYPE} from '../../core/constants';
+import {GraphLayout, GraphLayoutProps} from '../../core/graph-layout';
 import {Graph} from '../../graph/graph';
 
-export type RadialLayoutOptions = GraphLayoutOptions & {
+export type RadialLayoutProps = GraphLayoutProps & {
   radius?: number;
   tree?: any;
 };
@@ -52,8 +51,8 @@ const getPath = (node, targetId, path) => {
   return false;
 };
 
-export class RadialLayout extends GraphLayout<RadialLayoutOptions> {
-  static defaultOptions = {
+export class RadialLayout extends GraphLayout<RadialLayoutProps> {
+  static defaultProps = {
     radius: 500
   };
 
@@ -63,10 +62,10 @@ export class RadialLayout extends GraphLayout<RadialLayoutOptions> {
   _hierarchicalPoints = {};
   nestedTree;
 
-  constructor(options: RadialLayoutOptions = {}) {
+  constructor(options: RadialLayoutProps = {}) {
     super(options);
     this._options = {
-      ...RadialLayout.defaultOptions,
+      ...RadialLayout.defaultProps,
       ...options
     };
   }
@@ -149,6 +148,12 @@ export class RadialLayout extends GraphLayout<RadialLayoutOptions> {
     this._onLayoutDone();
   }
 
+  stop(): void {}
+
+  resume() {}
+
+  update() {}
+
   getNodePosition = (node) => {
     return this._hierarchicalPoints[node.id];
   };
@@ -185,7 +190,7 @@ export class RadialLayout extends GraphLayout<RadialLayoutOptions> {
     }
 
     return {
-      type: EDGE_TYPE.SPLINE_CURVE,
+      type: 'spline-curve',
       sourcePosition: sourceNodePos,
       targetPosition: targetNodePos,
       controlPoints: wayPoints
@@ -197,6 +202,13 @@ export class RadialLayout extends GraphLayout<RadialLayoutOptions> {
     this._onLayoutChange();
     this._onLayoutDone();
   };
+
+  protected override _updateBounds(): void {
+    const positions = Object.values(this._hierarchicalPoints ?? {}).map((position) =>
+      this._normalizePosition(position)
+    );
+    this._bounds = this._calculateBounds(positions);
+  }
 }
 
 function rotate(cx, cy, x, y, angle) {

package/src/layouts/gpu-force/gpu-force-layout.ts

@@ -2,11 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GraphLayout, GraphLayoutOptions} from '../../core/graph-layout';
+import {GraphLayout, GraphLayoutProps} from '../../core/graph-layout';
 
-import {EDGE_TYPE} from '../../core/constants';
-
-export type GPUForceLayoutOptions = GraphLayoutOptions & {
+export type GPUForceLayoutOptions = GraphLayoutProps & {
   alpha?: number;
   resumeAlpha?: number;
   nBodyStrength?: number;
@@ -19,7 +17,7 @@ export type GPUForceLayoutOptions = GraphLayoutOptions & {
  * @todo this layout should be updated with the organizational and logic improvements made in d3-force
  */
 export class GPUForceLayout extends GraphLayout<GPUForceLayoutOptions> {
-  static defaultOptions: Required<GPUForceLayoutOptions> = {
+  static defaultProps: Required<GPUForceLayoutOptions> = {
     alpha: 0.3,
     resumeAlpha: 0.1,
     nBodyStrength: -900,
@@ -33,12 +31,12 @@ export class GPUForceLayout extends GraphLayout<GPUForceLayoutOptions> {
   private _nodeMap: any;
   private _edgeMap: any;
   private _graph: any;
-  private _worker: Worker;
+  private _worker: Worker | null = null;
   private _callbacks: any;
 
   constructor(options: GPUForceLayoutOptions = {}) {
     const _options = {
-      ...GPUForceLayout.defaultOptions,
+      ...GPUForceLayout.defaultProps,
       ...options
     };
 
@@ -50,6 +48,10 @@ export class GPUForceLayout extends GraphLayout<GPUForceLayoutOptions> {
     this._d3Graph = {nodes: [], edges: []};
     this._nodeMap = {};
     this._edgeMap = {};
+    this._callbacks = {
+      onLayoutChange: this._onLayoutChange,
+      onLayoutDone: this._onLayoutDone
+    };
   }
 
   initializeGraph(graph) {
@@ -143,7 +145,10 @@ export class GPUForceLayout extends GraphLayout<GPUForceLayoutOptions> {
     throw new Error('Resume unavailable');
   }
   stop() {
-    this._worker.terminate();
+    if (this._worker) {
+      this._worker.terminate();
+      this._worker = null;
+    }
   }
 
   // for steaming new data on the same graph
@@ -232,14 +237,14 @@ export class GPUForceLayout extends GraphLayout<GPUForceLayoutOptions> {
     const targetPosition = d3Edge && d3Edge.target;
     if (d3Edge && sourcePosition && targetPosition) {
       return {
-        type: EDGE_TYPE.LINE,
+        type: 'line',
         sourcePosition: [sourcePosition.x, sourcePosition.y],
         targetPosition: [targetPosition.x, targetPosition.y],
         controlPoints: []
       };
     }
     return {
-      type: EDGE_TYPE.LINE,
+      type: 'line',
       sourcePosition: [0, 0],
       targetPosition: [0, 0],
       controlPoints: []
@@ -261,4 +266,11 @@ export class GPUForceLayout extends GraphLayout<GPUForceLayoutOptions> {
     d3Node.fx = null;
     d3Node.fy = null;
   };
+
+  protected override _updateBounds(): void {
+    const positions = Object.values(this._nodeMap ?? {}).map((node) =>
+      this._normalizePosition(node)
+    );
+    this._bounds = this._calculateBounds(positions);
+  }
 }

package/src/layouts/simple-layout.ts

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GraphLayout, GraphLayoutOptions} from '../core/graph-layout';
+import {GraphLayout, GraphLayoutProps} from '../core/graph-layout';
 import {Node} from '../graph/node';
-import {EDGE_TYPE} from '../core/constants';
+import {Edge} from '../graph/edge';
 import {Graph} from '../graph/graph';
 
-export type SimpleLayoutOptions = GraphLayoutOptions & {
+export type SimpleLayoutProps = GraphLayoutProps & {
   /** The accessor lets the application supply the position ([x, y]) of each node.
    * @example
     ```js
@@ -28,8 +28,8 @@ export type SimpleLayoutOptions = GraphLayoutOptions & {
 };
 
 /** A basic layout where the application controls positions of each node */
-export class SimpleLayout extends GraphLayout<SimpleLayoutOptions> {
-  static defaultOptions: Required<SimpleLayoutOptions> = {
+export class SimpleLayout extends GraphLayout<SimpleLayoutProps> {
+  static defaultProps: Required<SimpleLayoutProps> = {
     nodePositionAccessor: (node) =>
       [node.getPropertyValue('x'), node.getPropertyValue('y')] as [number, number]
   };
@@ -37,26 +37,22 @@ export class SimpleLayout extends GraphLayout<SimpleLayoutOptions> {
   protected readonly _name = 'SimpleLayout';
   protected _graph: Graph | null = null;
   protected _nodeMap: Record<string, Node> = {};
-  protected _nodePositionMap: Record<string, (node: Node) => [number, number]> = {};
+  protected _nodePositionMap: Record<string, [number, number] | null> = {};
 
-  constructor(options: SimpleLayoutOptions = {}) {
-    super({...SimpleLayout.defaultOptions, ...options});
+  constructor(options: SimpleLayoutProps = {}) {
+    super({...SimpleLayout.defaultProps, ...options});
   }
 
   initializeGraph(graph: Graph): void {
     this.updateGraph(graph);
   }
 
-  _notifyLayoutComplete(): void {
-    this._onLayoutStart();
-    this._onLayoutChange();
-    this._onLayoutDone();
-  }
-
   start(): void {
     this._notifyLayoutComplete();
   }
 
+  stop() : void {}
+
   update(): void {
     this._notifyLayoutComplete();
   }
@@ -71,32 +67,59 @@ export class SimpleLayout extends GraphLayout<SimpleLayoutOptions> {
       res[node.getId()] = node;
       return res;
     }, {});
-    this._nodePositionMap = graph.getNodes().reduce((res, node) => {
-      res[node.getId()] = this._options.nodePositionAccessor(node);
-      return res;
-    }, {});
+    this._nodePositionMap = graph.getNodes().reduce<Record<string, [number, number] | null>>(
+      (res, node) => {
+        res[node.getId()] = this._normalizePosition(
+          this._options.nodePositionAccessor(node)
+        );
+        return res;
+      },
+      {}
+    );
   }
 
   setNodePositionAccessor = (accessor) => {
     (this._options as any).nodePositionAccessor = accessor;
   };
 
-  getNodePosition = (node) => this._nodePositionMap[node.getId()] as any;
+  getNodePosition = (node: Node | null): [number, number] => {
+    if (!node) {
+      return [0, 0] as [number, number];
+    }
+    const position = this._nodePositionMap[node.getId()];
+    return position ?? [0, 0] as [number, number];
+  };
 
-  getEdgePosition = (edge) => {
-    const sourcePos = this._nodePositionMap[edge.getSourceNodeId()];
-    const targetPos = this._nodePositionMap[edge.getTargetNodeId()];
+  getEdgePosition = (edge: Edge) => {
+    const sourceNode = this._nodeMap[edge.getSourceNodeId()];
+    const targetNode = this._nodeMap[edge.getTargetNodeId()];
+    const sourcePos = sourceNode ? this.getNodePosition(sourceNode) : [0, 0];
+    const targetPos = targetNode ? this.getNodePosition(targetNode) : [0, 0];
     return {
-      type: EDGE_TYPE.LINE,
+      type: 'line',
       sourcePosition: sourcePos,
       targetPosition: targetPos,
       controlPoints: []
-    } as any;
+    };
   };
 
   lockNodePosition = (node, x, y) => {
-    this._nodePositionMap[node.getId()] = [x, y] as any;
+    this._nodePositionMap[node.getId()] = [x, y];
     this._onLayoutChange();
     this._onLayoutDone();
   };
+
+  _notifyLayoutComplete(): void {
+    this._onLayoutStart();
+    this._onLayoutChange();
+    this._onLayoutDone();
+  }
+
+
+  protected override _updateBounds(): void {
+    const positions = Object.values(this._nodePositionMap).map((position) =>
+      this._normalizePosition(position)
+    );
+    this._bounds = this._calculateBounds(positions);
+  }
 }

package/src/loaders/edge-parsers.ts

@@ -3,13 +3,13 @@
 // Copyright (c) vis.gl contributors
 
 import type {EdgeOptions} from '../graph/edge';
-import {log} from '../utils/log';
+import {error} from '../utils/log';
 
 export function basicEdgeParser(edge: any): Omit<EdgeOptions, 'data'> {
   const {id, directed, sourceId, targetId} = edge;
 
   if (sourceId === undefined || targetId === undefined) {
-    log.error('Invalid edge: sourceId or targetId is missing.')();
+    error('Invalid edge: sourceId or targetId is missing.');
     return null;
   }
 

package/src/loaders/json-loader.ts

@@ -5,12 +5,12 @@
 import {createGraph} from './create-graph';
 import {basicNodeParser} from './node-parsers';
 import {basicEdgeParser} from './edge-parsers';
-import {log} from '../utils/log';
+import {error} from '../utils/log';
 
 export const JSONLoader = ({json, nodeParser = basicNodeParser, edgeParser = basicEdgeParser}) => {
   const {name = 'default', nodes, edges} = json;
   if (!nodes) {
-    log.error('Invalid graph: nodes is missing.')();
+    error('Invalid graph: nodes is missing.');
     return null;
   }
 

package/src/loaders/node-parsers.ts

@@ -3,11 +3,11 @@
 // Copyright (c) vis.gl contributors
 
 import type {NodeOptions} from '../graph/node';
-import {log} from '../utils/log';
+import {error} from '../utils/log';
 
 export function basicNodeParser(node: any): Pick<NodeOptions, 'id'> {
   if (node.id === undefined) {
-    log.error('Invalid node: id is missing.')();
+    error('Invalid node: id is missing.');
     return null;
   }
   return {id: node.id};

package/src/loaders/simple-json-graph-loader.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {createGraph} from './create-graph';
-import {log} from '../utils/log';
+import {error} from '../utils/log';
 import {basicNodeParser} from './node-parsers';
 import {basicEdgeParser} from './edge-parsers';
 
@@ -19,7 +19,7 @@ export function loadSimpleJSONGraph(
   const {nodeParser = basicNodeParser, edgeParser = basicEdgeParser} = options;
   const {name = 'default', nodes, edges} = json;
   if (!nodes) {
-    log.error('Invalid graph: nodes is missing.')();
+    error('Invalid graph: nodes is missing.');
     return null;
   }
 

package/src/loaders/table-graph-loader.ts

@@ -8,7 +8,7 @@ import {Edge} from '../graph/edge';
 import {Node} from '../graph/node';
 import {Graph} from '../graph/graph';
 
-import {log} from '../utils/log';
+import {error} from '../utils/log';
 
 export type ParseGraphOptions = {
   nodeIdField?: string;
@@ -73,7 +73,7 @@ export function tableGraphLoader(
   // add nodes
 
   if (!nodes) {
-    log.error('Invalid graph: nodes is missing.')();
+    error('Invalid graph: nodes is missing.');
     return null;
   }