@cosmos.gl/graph 2.6.1 → 2.6.2-rc.0

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { D3ZoomEvent } from 'd3-zoom';
 import { D3DragEvent } from 'd3-drag';
-import { type Hovered } from '@/graph/modules/Store';
+import { Hovered } from './modules/Store';
 export interface GraphConfigInterface {
     /**
      * If set to `false`, the simulation will not run.

package/dist/helper.d.ts

@@ -1,5 +1,5 @@
-import regl from 'regl';
-import DOMPurify from 'dompurify';
+import { default as regl } from 'regl';
+import { default as DOMPurify } from 'dompurify';
 export declare const isFunction: <T>(a: T) => boolean;
 export declare const isArray: <T>(a: unknown | T[]) => a is T[];
 export declare const isObject: <T>(a: T) => boolean;

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import 'd3-transition';
-import { GraphConfig, GraphConfigInterface } from '@/graph/config';
-import { GraphData } from '@/graph/modules/GraphData';
+import { GraphConfig, GraphConfigInterface } from './config';
+import { GraphData } from './modules/GraphData';
 export declare class Graph {
     config: GraphConfig;
     graph: GraphData;
@@ -257,11 +256,13 @@ export declare class Graph {
      */
     setPinnedPoints(pinnedIndices: number[] | null): void;
     /**
-     * Renders the graph.
+     * Renders the graph and starts rendering.
+     * Does NOT modify simulation state - use start(), stop(), pause(), unpause() to control simulation.
      *
-     * @param {number} [simulationAlpha] - Optional value between 0 and 1
-     * that controls the initial energy of the simulation.The higher the value,
-     * the more initial energy the simulation will get. Zero value stops the simulation.
+     * @param {number} [simulationAlpha] - Optional alpha value to set.
+     *   - If 0: Sets alpha to 0, simulation stops after one frame (graph becomes static).
+     *   - If positive: Sets alpha to that value.
+     *   - If undefined: Keeps current alpha value.
      */
     render(simulationAlpha?: number): void;
     /**
@@ -458,12 +459,19 @@ export declare class Graph {
     getScaleY(): ((y: number) => number) | undefined;
     /**
      * Start the simulation.
+     * This only controls the simulation state, not rendering.
      * @param alpha Value from 0 to 1. The higher the value, the more initial energy the simulation will get.
      */
     start(alpha?: number): void;
+    /**
+     * Stop the simulation. This stops the simulation and resets its state.
+     * Use start() to begin a new simulation cycle.
+     */
+    stop(): void;
     /**
      * Pause the simulation. When paused, the simulation stops running
-     * and can be resumed using the unpause method.
+     * but preserves its current state (progress, alpha).
+     * Can be resumed using the unpause method.
      */
     pause(): void;
     /**
@@ -478,7 +486,8 @@ export declare class Graph {
      */
     restart(): void;
     /**
-     * Render only one frame of the simulation (stops the simulation if it was running).
+     * Run one step of the simulation manually.
+     * Works even when the simulation is paused.
      */
     step(): void;
     /**
@@ -501,10 +510,42 @@ export declare class Graph {
      * @returns An array of tuple positions
      */
     pair(pointPositions: number[]): [number, number][];
+    /**
+     * Updates and recreates the graph visualization based on pending changes.
+     *
+     * @param simulationAlpha - Optional alpha value to set. If not provided, keeps current alpha.
+     */
     private update;
+    /**
+     * Runs one step of the simulation (forces, position updates, alpha decay).
+     * This is the core simulation logic that can be called by step() or during rendering.
+     *
+     * @param forceExecution - Controls whether to run the simulation step when paused.
+     *   - If true: Always runs the simulation step, even when isSimulationRunning is false.
+     *     Used by step() to allow manual stepping while the simulation is paused.
+     *   - If false: Only runs if isSimulationRunning is true. Used during rendering
+     *     to respect pause/unpause state.
+     */
+    private runSimulationStep;
     private initPrograms;
+    /**
+     * The rendering loop - schedules itself to run continuously
+     */
     private frame;
+    /**
+     * Renders a single frame (the actual rendering logic).
+     * This does NOT schedule the next frame.
+     */
+    private renderFrame;
     private stopFrames;
+    /**
+     * Starts continuous rendering
+     */
+    private startFrames;
+    /**
+     * Called automatically when simulation completes (alpha < ALPHA_MIN).
+     * Rendering continues after this is called (for rendering/interaction).
+     */
     private end;
     private onClick;
     private updateMousePosition;