@neo4j-nvl/base 0.3.9-dc45154c → 1.0.0

package/dist/types/index.d.ts

@@ -11,9 +11,10 @@ import { nvlResultTransformer } from './utils/jsDriverResultTransformer';
 import { getZoomTargetForNodePositions } from './utils/zoomFunctions';
 /**
  * Extends the MouseEvent interface with the {@link HitTargets} property.
- * The result of a _.{@link NVL.getHits} call.
+ * The result of a {@link NVL.getHits} call.
  */
 interface NvlMouseEvent extends MouseEvent {
+    /** The graph elements that have been hit by the pointer event. */
     nvlTargets: HitTargets;
 }
 /**
@@ -37,26 +38,31 @@ interface NvlMouseEvent extends MouseEvent {
  */
 declare class NVL {
     #private;
+    /**
+     * @internal
+     * @hidden
+     */
+    readonly performance: any;
     /**
      * Creates a new NVL instance.
-     * @param {HTMLElement} frame - The DOM element to display the graph in
-     * @param {Node[]} nvlNodes - An Array of nodes
-     * @param {Relationship[]} nvlRels - An Array of relationships
-     * @param {NvlOptions} options - Options for the NVL instance
-     * @param {ExternalCallbackHandler} callbacks - Callbacks triggered on NVL events
+     * @param frame - The DOM element to display the graph in.
+     * @param nvlNodes - An array of {@link Node nodes}.
+     * @param nvlRels - An array of {@link Relationship relationships}.
+     * @param options - The {@link NvlOptions options} for the NVL instance.
+     * @param callbacks - Callbacks triggered on NVL events.
      */
     constructor(frame: HTMLElement, nvlNodes?: Node[], nvlRels?: Relationship[], options?: NvlOptions, callbacks?: ExternalCallbacks);
     /**
      * Restarts the NVL instance.
-     * @param {NvlOptions} options - new options for the NVL instance
-     * @param {boolean} retainPositions - whether or not to retain the current node positions
+     * @param options - New {@link NvlOptions} for the NVL instance.
+     * @param retainPositions - Whether or not to retain the current node positions.
      * New options will be merged with current options
      */
     restart(options?: NvlOptions, retainPositions?: boolean): void;
     /**
      * Adds nodes and relationships to NVL and updates existing nodes and relationships.
-     * @param {Node[] | PartialNode[]} nodes - An Array of nodes to be added or updated
-     * @param {Relationship[] | PartialRelationship[]} relationships - An Array of relationships to be added or updated
+     * @param nodes - An Array of {@link Node nodes} to be added or updated.
+     * @param relationships - An Array of {@link Relationship relationships} to be added or updated.
      * To update nodes or relationships, they must have an id that matches the id of the
      * node or relationship to be updated.
      * Only the properties that are provided will be updated.
@@ -84,18 +90,18 @@ declare class NVL {
     addAndUpdateElementsInGraph(nodes?: Node[] | PartialNode[], relationships?: Relationship[] | PartialRelationship[]): void;
     /**
      * Gets the currently selected nodes.
-     * @returns {(Node & Point)[]} An array of all currently selected nodes and their positions.
+     * @returns An array of all currently selected {@link Node nodes} and their positions.
      */
     getSelectedNodes(): (Node & Point)[];
     /**
      * Gets the currently selected relationships.
-     * @returns {Relationship[]} An array of all currently selected relationships.
+     * @returns An array of all currently selected {@link Relationship relationships}.
      */
     getSelectedRelationships(): Relationship[];
     /**
      * Updates relationships in the current scene with the provided array of nodes and relationships.
-     * @param {Node[] | PartialNode[]} nodes The updated nodes.
-     * @param {Relationship[] | PartialRelationship[]} relationships The updated relationships.
+     * @param nodes - The updated {@link Node nodes}.
+     * @param relationships - The updated {@link Relationship relationships}.
      * Ignores any nodes or relationships that do not exist in the current scene.
      * To update nodes or relationships, they must have an id that matches the id of the
      * node or relationship to be updated.
@@ -121,54 +127,53 @@ declare class NVL {
     updateElementsInGraph(nodes: Node[] | PartialNode[], relationships: Relationship[] | PartialRelationship[]): void;
     /**
      * Adds nodes and relationships in the current scene.
-     * @param {Node[]} nodes The nodes to be added.
-     * @param {Relationship[]} relationships The relationships to be added.
+     * @param nodes - The nodes to be added.
+     * @param relationships - The relationships to be added.
      */
     addElementsToGraph(nodes: Node[], relationships: Relationship[]): void;
     /**
      * Removes the specified nodes from the current scene.
-     * @param {string[]} nodeIds The node ids to be removed.
+     * @param nodeIds - The node ids to be removed.
      * Adjacent relationships will also be removed.
      */
     removeNodesWithIds(nodeIds: string[]): void;
     /**
      * Removes the specified relationships from the current scene.
-     * @param {string[]} relationshipIds The relationship ids to be removed.
+     * @param relationshipIds - The relationship ids to be removed.
      */
     removeRelationshipsWithIds(relationshipIds: string[]): void;
     /**
      * Returns all nodes that is currently stored in the visualisation.
-     * @returns {Node[]} The array of nodes.
+     * @returns The array of {@link Node nodes}.
      */
     getNodes(): Node[];
     /**
      * Returns the relationships that are currently in the visualization.
-     * @returns {Relationship[]} An array of the relationships in the visualization.
+     * @returns An array of the {@link Relationship relationships} in the visualization.
      */
     getRelationships(): Relationship[];
     /**
      * Returns the node data that is currently stored in the visualisation for a given id.
-     * @param {string} id The id of the node that should be returned.
-     * @returns {Node} The node or undefined if there is no node with the given id.
+     * @param id - The id of the {@link Node node} that should be returned.
+     * @returns The {@link Node node} or undefined if there is no node with the given id.
      */
     getNodeById(id: string): Node;
     /**
      * Returns the relationship data that is currently stored in the visualisation for a given id.
-     * @param {string} id The id of the relationship that should be returned.
-     * @returns {Relationship} The relationship or undefined if there is no relationship with the given id.
+     * @param id - The id of the {@link Relationship relationship} that should be returned.
+     * @returns The {@link Relationship relationship} or undefined if there is no relationship with the given id.
      */
     getRelationshipById(id: string): Relationship;
     /**
      * Returns the node position that is currently stored in the visualisation for a given id.
-     * @param {string} id The id of the node position that should be returned.
-     * @returns {Node} The position information for the given id, or undefined if there is no such node
+     * @param id - The id of the node position that should be returned.
+     * @returns The position information for the given id, or undefined if there is no such {@link Node node}.
      * or the layout has not yet run with that node.
      */
     getPositionById(id: string): Node;
     /**
      * Returns the current options.
-     * @returns {NvlOptions} The current options.
-     * @internal
+     * @returns The current options.
      */
     getCurrentOptions(): NvlOptions;
     /** Removes the graph visualization from the DOM and cleans up everything. */
@@ -179,26 +184,21 @@ declare class NVL {
     deselectAll(): void;
     /**
      * Updates pan and zoom fit the specified nodes in the viewport.
-     * @param {string[]} nodeIds The ids of the nodes to fit on the screen,
-     * @param {NvlState['zoomOptions']} zoomOptions specific options on how to transition the zoom
+     * @param nodeIds - The ids of the nodes to fit on the screen.
+     * @param zoomOptions - Specific options on how to transition the zoom.
+     *
+     * @remarks
      * If the zoom level required to fit the provided nodes is outside of the range provided by the
-     * {@link NvlOptions.minZoom} and {@link NvlOptions.maxZoom} options,
-     * and {@link NvlOptions.allowDynamicMinZoom} is set to `false`,
+     * {@link NvlOptions.minZoom minZoom} and {@link NvlOptions.maxZoom maxZoom} options, and the
+     * {@link NvlOptions.allowDynamicMinZoom allowDynamicMinZoom} option is set to `false`,
      * the zoom level will be set to the closest valid zoom level,
      * even if the given nodes do not fit the viewport yet.
      */
     fit(nodeIds: string[], zoomOptions?: NvlState['zoomOptions']): void;
     /**
-     * Resets the zoom of the viewport back to the default zoom level of 0.75
+     * Resets the zoom of the viewport back to the default zoom level of 0.75.
      */
     resetZoom(): void;
-    /**
-     * Toggles between the WebGL and Canvas rendering.
-     * @deprecated use {@link setRenderer} instead.
-     * @param {boolean} enabled Whether or not WebGL renderer should be used.
-     * @internal
-     */
-    setUseWebGLRenderer(enabled: boolean): void;
     /**
      * Switches between rendering methods
      * @param renderer - which rendering method to use
@@ -206,79 +206,88 @@ declare class NVL {
     setRenderer(renderer: string): void;
     /**
      * Restarts NVL with or without WebGL support.
-     * @param {boolean} disabled Whether or not WebGL should be disabled.
-     * Not to be confused with {@link setUseWebGLRenderer}, which only affects the rendering method
+     * @param disabled - Whether or not WebGL should be disabled.
      * @experimental
      */
     setDisableWebGL(disabled?: boolean): void;
     /**
      * Pins the specified node so it is not affected by layout forces.
-     * @param {string} nodeId The id of the node to be pinned.
+     * @param nodeId - The id of the node to be pinned.
      */
     pinNode(nodeId: string): void;
     /**
      * Un-pins the specified nodes so it is affected by layout forces again.
-     * @param {string[]} nodeIds The ids of the nodes to be un-pinned.
+     * @param nodeIds The ids of the nodes to be un-pinned.
      */
     unPinNode(nodeIds: string[]): void;
     /**
      * Changes the layout type.
-     * @param {Layout} layout The layout type.
+     * @param layout - The {@link Layout} type.
      */
     setLayout(layout: Layout): void;
     /**
      * Updates the configuration of the current layout.
-     * @param {LayoutOptions} options The layout configuration.
+     * @param options - The {@link LayoutOptions} configuration.
      */
     setLayoutOptions(options: LayoutOptions): void;
     /**
      * Returns the nodes that are currently in the visualization.
      * The `rels` property of the returned object is always empty.
-     * @returns {{ nodes: Node[], rels: Relationship [] }} An array of the nodes in the visualization.
+     * @returns An object containing the nodes and relationships in the visualization.
      */
     getNodesOnScreen(): {
+        /** The nodes in the visualization. */
         nodes: Node[];
+        /** The relationships in the visualization. */
         rels: Relationship[];
     };
     /**
      * Fetches and returns the current positions of all nodes as an array of coordinates.
-     * @returns {(Node & Point)[]} An array of node positions.
+     * @returns An array of {@link Node node} positions.
      */
     getNodePositions(): (Node & Point)[];
     /**
-     * Sets the node positions based on data provided
-     * @param {Node[]} data The positions that the nodes should be set to.
-     * @param {boolean} updateLayout whether or not the current layout algorithm
+     * Sets the node positions based on data provided.
+     * @param data - The positions that the nodes should be set to.
+     * @param updateLayout - Whether or not the current layout algorithm
      * should update the graph after setting the node positions.
-     * For node positions to be unaffected by layout algorithms, use the {@link FreeLayoutType}
+     *
+     * @remarks
+     * For node positions to be unaffected by layout algorithms, use the 'free' layout type
      * or use {@link pinNode} to pin the nodes that should remain still.
      * False by default.
      */
     setNodePositions(data: Node[], updateLayout?: boolean): void;
     /**
      * Checks and returns whether the current layout is still in flux.
-     * @returns {boolean} Whether or not the layout is moving.
+     * @returns Whether or not the layout is moving.
      */
     isLayoutMoving(): boolean;
     /**
      * Saves the current view of the graph visualization canvas as a png to the client.
      * @param {{ filename: string, backgroundColor: string }} options The filename and background color of the png.
-     * @param {string} options.filename The filename of the png file.
-     * @param {string} options.backgroundColor - The background color of the png file.
+     * @param options.filename - The filename of the png file.
+     * @param options.backgroundColor - The background color of the png file.
      * The size of the png file will be the size of the canvas in the DOM.
      */
     saveToFile(options?: {
         filename?: string;
         backgroundColor?: string;
     }): void;
+    /**
+     * Returns the current view of the graph visualization canvas as a data URL.
+     * @param options - The options for the image.
+     * @param options.backgroundColor - The background color of the data URL.
+     * @returns A data URL of the current view of the graph visualization canvas.
+     */
     getImageDataUrl(options?: {
         backgroundColor?: string;
     }): string;
     /**
      * Saves the entire graph visualization canvas as a png to the client.
      * @param {{ filename: string, backgroundColor: string }} options The filename and background color of the png.
-     * @param {string} options.filename The filename of the png file.
-     * @param {string} options.backgroundColor - The background color of the png file.
+     * @param options.filename - The filename of the png file.
+     * @param options.backgroundColor - The background color of the png file.
      * The size of the png file will be as large as the entire graph at the default zoom level.
      * Can result in a very large file.
      */
@@ -288,32 +297,35 @@ declare class NVL {
     }): void;
     /**
      * Sets the zoom of the viewport to a specific value.
-     * @param {number} absolute The desired zoom level.
+     * @param zoomValue - The desired zoom level.
+     * @remarks
+     *
      * When updating both the zoom level and pan coordinates,
      * use {@link setZoomAndPan} instead of calling {@link setZoom} and {@link setPan}
      * separately to avoid jittering.
+     *
      * If the zoom level is outside of the range provided by the
      * {@link NvlOptions.minZoom} and {@link NvlOptions.maxZoom} options,
      * the zoom level will be set to the closest valid zoom level.
      * If {@link NvlOptions.allowDynamicMinZoom} is set to true,
      * the {@link NvlOptions.minZoom} option will be ignored of the current graph does not fit the viewport.
      */
-    setZoom(absolute: number): void;
+    setZoom(zoomValue: number): void;
     /**
      * Sets the zoom of the viewport to a specific value.
-     * @param {number} panX The desired panX value.
-     * @param {number} panY The desired panY value.
-     * When updating both the zoom level and pan coordinates,
-     * use {@link setZoomAndPan} instead of calling {@link setZoom} and {@link setPan}
-     * separately to avoid jittering.
+     * @param panX - The desired panX value.
+     * @param panY - The desired panY value.
+     * @remarks When updating both the zoom level and pan coordinates,
+     * use {@link setZoomAndPan} instead of calling {@link setZoom} and {@link setPan} separately to avoid jittering.
      */
     setPan(panX: number, panY: number): void;
     /**
      * Sets the zoom and pan of the viewport to specific values.
-     * @param {number} zoom The desired zoom level.
-     * @param {number} panX The desired panX value.
-     * @param {number} panY The desired panY value.
-     * When only updating the zoom level or pan coordinates, use {@link setZoom} or {@link setPan} instead.
+     * @param zoom - The desired zoom level.
+     * @param panX - The desired panX value.
+     * @param panY - The desired panY value.
+     * @remarks When only updating zoom level or pan coordinates, use {@link setZoom} or {@link setPan} instead.
+     *
      * If the zoom level is outside of the range provided by the
      * {@link NvlOptions.minZoom} and {@link NvlOptions.maxZoom} options,
      * the zoom level will be set to the closest valid zoom level.
@@ -323,18 +335,18 @@ declare class NVL {
     setZoomAndPan(zoom: number, panX: number, panY: number): void;
     /**
      * Get the current zoom level of the viewport.
-     * @returns {number} The current zoom level
+     * @returns The current zoom level.
      */
     getScale(): number;
     /**
      * Returns the current pan of the viewport.
-     * @returns {Point} The current pan of the viewport.
+     * @returns The current pan of the viewport.
      */
     getPan(): Point;
     /**
      * Gets the nodes and relationships that have been hit by a pointer event.
-     * @param evt The mouse event.
-     * @param targets The graph elements to check for hits. Defaults to ['node', 'relationship'].
+     * @param evt - The mouse event.
+     * @param targets - The graph elements to check for hits. Defaults to ['node', 'relationship'].
      * @param hitOptions - Options for the hit test.
      * @returns A {@link NvlMouseEvent} with the {@link HitTargets} property
      * containing the nodes and relationships that have been hit by the pointer event.
@@ -364,6 +376,7 @@ declare class NVL {
 /**
  * Functions for mapping colors.
  * @internal
+ * @hidden
  */
 declare const colorMapperFunctions: {
     textColorForBackground: (color: string) => string;

package/dist/types/layouts/animatedlayout/animationUtils.d.ts

@@ -2,8 +2,8 @@ import type { Node } from '../../types/graph-element';
 import type { Point } from '../../utils/geometry';
 /**
  * Calculates the average node coordinates for a given set of nodes.
- * @param {Node[]} nodes The nodes to calculate the average position for.
- * @param {Record<string, Node | Point>} positions The positions of the nodes.
- * @returns {number[]} The average node coordinates.
+ * @param nodes - The nodes to calculate the average position for.
+ * @param positions - The positions of the nodes.
+ * @returns The average node coordinates.
  */
 export declare const calculateAverageNodePosition: (nodes: Node[], positions: Record<string, Node | Point>) => number[];

package/dist/types/layouts/forcedirectedlayout/physlayout/PhysLayout.d.ts

@@ -58,15 +58,15 @@ export declare class PhysLayout {
         state: NvlState;
     });
     /**
-     * Sets the layout options
-     * @param {ForceDirectedOptions} options the object with the options
-     * @param {boolean} [initial=false] whether this is the first setting of options
+     * Sets the layout options.
+     * @param options - The object with the options.
+     * @param initial - Whether this is the first setting of options.
      */
     setOptions(options?: ForceDirectedOptions, initial?: boolean): void;
     /**
      * Sets graph data to be used
      * @param {{ nodes: Node[]; rels: Relationship[] }} data the graph object
-     * @returns the top level graph of the subgraphs created by the solar merger
+     * @returns The top level graph of the subgraphs created by the solar merger.
      */
     setData(data: {
         nodes: Node[];
@@ -75,7 +75,7 @@ export declare class PhysLayout {
     /**
      * Updates the node's positions for the next step in the physics layout iterations if the layout needs to update
      * @param refreshPositions whether the entire layout should be reheated
-     * @returns whether the layout should update in the following step
+     * @returns Whether the layout should update in the following step.
      */
     update(refreshPositions?: boolean): boolean;
     /**
@@ -84,24 +84,24 @@ export declare class PhysLayout {
     terminateUpdate(): void;
     /**
      * Returns whether the current layout needs to be updated in the next iteration step.
-     * @returns {boolean} Whether the layout should update in the following step.
+     * @returns Whether the layout should update in the following step.
      */
     getShouldUpdate(): boolean;
     /**
      * Returns whether the current layout is computing.
      * Always returns false because the force-directed layout has no computing step
-     * @returns {boolean} Whether the layout is computing.
+     * @returns Whether the layout is computing.
      */
     getComputing(): boolean;
     /**
      * Adds the current x,y coordinates for each node to a given list of nodes.
-     * @param {Node[]} nodeList The list of nodes to get positions for.
-     * @returns {(Node & Point)[]} The list of nodes containing the x,y coordinates on each node object.
+     * @param nodeList - The list of nodes to get positions for.
+     * @returns The list of nodes containing the x,y coordinates on each node object.
      */
     getNodePositions(nodeList: Node[]): (Node & Point)[];
     /**
      * Reheats the layout
-     * @param {Object} fullData The entire graph object.
+     * @param fullData - The entire graph object.
      */
     reheat(fullData: {
         nodes: Node[];
@@ -109,17 +109,17 @@ export declare class PhysLayout {
     }): void;
     /**
      * Updates the existing nodes of a graph with a given list of updates
-     * @param {Node[]} nodeList The list of updates.
+     * @param nodeList - The list of updates.
      */
     updateNodes(nodeList: Node[]): void;
     /**
      * Adds and removes nodes from the graph based on given updates
-     * @param {Object} fullData The entire graph object.
-     * @param {Array<Object>} fullData.nodes the nodes in the graph
-     * @param {Array<Object>} fullData.rels the relationships in the graph
-     * @param {Object} nodeChanges The changes in the graph.
-     * @param {Array<Object>} nodeChanges.adds A list of nodes to be added.
-     * @param {Array<Object>} nodeChanges.removes A list of nodes to be removed.
+     * @param fullData - The entire graph object.
+     * @param fullData.nodes - The nodes in the graph.
+     * @param fullData.rels - The relationships in the graph.
+     * @param nodeChanges - The changes in the graph.
+     * @param nodeChanges.adds - A list of nodes to be added.
+     * @param nodeChanges.removes - A list of nodes to be removed.
      */
     addRemoveData(fullData: {
         nodes: Node[];
@@ -137,11 +137,11 @@ export declare class PhysLayout {
     destroy(): void;
     /**
      * Takes the new flat key set of relationships and the current relationship changes
-     * and checks whether removed relationships are still in the new flat key set
+     * and checks whether removed relationships are still in the new flat key set.
      * and whether added relationships were already in the old flat key set.
      * @param newFlatKeySet The new flat key set of relationships.
      * @param relationshipChanges The changes in the relationships.
-     * @returns {boolean} Whether the relationship flat map has changed.
+     * @returns Whether the relationship flat map has changed.
      */
     private hasRelationshipFlatMapChanged;
     private dumpTexture;

package/dist/types/modules/CallbackHelper.d.ts

@@ -17,21 +17,21 @@ export declare class CallbackHelper {
     constructor();
     /**
      * Register a callback function to be called when an event of that name happens
-     * @param {string} name The name of the callback to register
-     * @param {function} callback A function that will be called when an event of that name happens
+     * @param name - The name of the callback to register.
+     * @param callback - A function that will be called when an event of that name happens.
      * If other callbacks are already registered for that name it is added to the list
      */
     register(name: keyof ExternalCallbacks, callback: CallbackFunction): void;
     /**
      * Check if a callback function with that name is registered already
-     * @param {string} name - The name of the callbacks to check
+     * @param name - The name of the callbacks to check.
      * @return {boolean} Whether or not a callback function with that name is registered
      */
     isCallbackRegistered(name: keyof ExternalCallbacks): boolean;
     /**
      * Call all callbacks registered for a given name
-     * @param {string} name - The name of the callbacks to call
-     * @param {object} data - Data to pass when calling the callbacks
+     * @param name - The name of the callbacks to call.
+     * @param data - Data to pass when calling the callbacks.
      */
     callIfRegistered(): void;
 }

package/dist/types/modules/ExternalCallbackHandler.d.ts

@@ -13,9 +13,16 @@ export interface ExternalCallbacks {
     onInitialization?: () => void;
     /** Triggered when a asynchronous layout calculation starts/stops. */
     onLayoutComputing?: (isComputing: boolean) => void;
+    /**
+     * Triggered when the WebGL context is lost.
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/webglcontextlost_event}
+     */
     onWebGLContextLost?: (webGLContextEvent: WebGLContextEvent) => void;
     /** Triggered when a zoom transition (e.g. {@link NVL.fit} or {@link NVL.resetZoom}) function is done. */
     onZoomTransitionDone?: () => void;
+    /**
+     * Triggered when NVL is restarted.
+     */
     restart?: () => void;
 }
 export declare const isExternalCallback: (callback: unknown) => callback is keyof ExternalCallbacks;

package/dist/types/modules/NvlController.d.ts

@@ -54,7 +54,7 @@ export default class NvlController {
     private layoutComputingCallback;
     private currentLayoutType;
     private descriptionElement;
-    constructor(state: NvlState, options: NvlOptions);
+    constructor(state: NvlState, frame: HTMLElement, options: NvlOptions);
     private onWebGLContextLost;
     private updateMinimapZoom;
     private startMainLoop;
@@ -63,8 +63,8 @@ export default class NvlController {
     dumpRelationships(): Relationship[];
     /**
      * Map a relative Canvas space to the DOM position
-     * @param {number} canvasX X position in the canvas space
-     * @param {number} canvasY Y position position in the canvas space
+     * @param canvasX - X position in the canvas space.
+     * @param canvasY - Y position position in the canvas space.
      */
     mapCanvasSpaceToRelativePosition(canvasX: number, canvasY: number): {
         x: number;
@@ -72,8 +72,8 @@ export default class NvlController {
     };
     /**
      * Map a relative DOM position to the Canvas space
-     * @param {*} clientX relative X position from the top left [0..rect.width]
-     * @param {*} clientY relative Y position from the top left [0..rect.height]
+     * @param clientX - Relative X position from the top left [0..rect.width].
+     * @param clientY - Relative Y position from the top left [0..rect.height].
      */
     mapRelativePositionToCanvasSpace(clientX: number, clientY: number): {
         x: number;

package/dist/types/modules/dataset.d.ts

@@ -32,6 +32,6 @@ export interface Channel<T> {
 export declare const getHtmlProperty: (item: Partial<Node | Relationship>) => HTMLElement | undefined;
 /**
  * Creates an empty dataset in which a graph be stored and updated using mobx actions.
- * @returns A new and empty {@link DataSet}
+ * @returns A new and empty {@link DataSet}.
  */
 export declare const createDataSet: <T extends Node | Relationship>() => DataSet<T>;

package/dist/types/modules/state/state.d.ts

@@ -2,7 +2,7 @@ import type { NvlOptions, NvlState } from './types';
 /**
  * Create a new NVL state
  *
- * @param {NvlOptions} options - The options for the new state
- * @returns {NvlState} - The state object
+ * @param options - The options for the new state.
+ * @returns The state object.
  */
 export declare const createState: (options: NvlOptions) => NvlState;