@cosmos.gl/graph 2.6.1 → 2.6.2

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.
@@ -58,6 +58,8 @@ export interface GraphConfigInterface {
      * if the size value in the array is `undefined` or `null`.
      * Default value: `4`
     */
+    pointDefaultSize?: number;
+    /** @deprecated Use `pointDefaultSize` instead */
     pointSize?: number;
     /**
      * Universal opacity value applied to all points.
@@ -135,6 +137,8 @@ export interface GraphConfigInterface {
      * The default width value to use for links when no link widths are provided or if the width value in the array is `undefined` or `null`.
      * Default value: `1`
     */
+    linkDefaultWidth?: number;
+    /** @deprecated Use `linkDefaultWidth` instead */
     linkWidth?: number;
     /**
      * The color to use for links when they are hovered.
@@ -185,6 +189,8 @@ export interface GraphConfigInterface {
      * The default link arrow value that controls whether or not to display link arrows.
      * Default value: `false`
      */
+    linkDefaultArrows?: boolean;
+    /** @deprecated Use `linkDefaultArrows` instead */
     linkArrows?: boolean;
     /**
      * Scale factor for the link arrows size.
@@ -553,6 +559,7 @@ export declare class GraphConfig implements GraphConfigInterface {
     pointGreyoutOpacity: undefined;
     pointGreyoutColor: undefined;
     pointSize: number;
+    pointDefaultSize: undefined;
     pointOpacity: number;
     pointSizeScale: number;
     hoveredPointCursor: string;
@@ -566,6 +573,7 @@ export declare class GraphConfig implements GraphConfigInterface {
     linkOpacity: number;
     linkGreyoutOpacity: number;
     linkWidth: number;
+    linkDefaultWidth: undefined;
     linkWidthScale: number;
     hoveredLinkColor: undefined;
     hoveredLinkWidthIncrease: number;
@@ -575,6 +583,7 @@ export declare class GraphConfig implements GraphConfigInterface {
     curvedLinkWeight: number;
     curvedLinkControlPointDistance: number;
     linkArrows: boolean;
+    linkDefaultArrows: undefined;
     linkArrowsSizeScale: number;
     scaleLinksOnZoom: boolean;
     linkVisibilityDistanceRange: number[];

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;