@react-fabric/graph 1.0.0-beta.58

package/dist/esm/packages/graph/src/programs/node-rect/base/index.js

@@ -0,0 +1,135 @@
+'use client';
+
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _inherits from '@babel/runtime/helpers/inherits';
+import { NodeProgram } from 'sigma/rendering';
+import { floatColor } from 'sigma/utils';
+import SHADER_SOURCE$1 from './frag.glsl.js';
+import SHADER_SOURCE from './vert.glsl.js';
+
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+
+/* istanbul ignore file */
+
+var _WebGLRenderingContex = WebGLRenderingContext,
+  UNSIGNED_BYTE = _WebGLRenderingContex.UNSIGNED_BYTE,
+  FLOAT = _WebGLRenderingContex.FLOAT;
+var UNIFORMS = ["u_sizeRatio", "u_correctionRatio", "u_cameraAngle", "u_matrix"];
+var PI = Math.PI;
+var NodeRectBase = /*#__PURE__*/function (_NodeProgram) {
+  function NodeRectBase() {
+    _classCallCheck(this, NodeRectBase);
+    return _callSuper(this, NodeRectBase, arguments);
+  }
+  _inherits(NodeRectBase, _NodeProgram);
+  return _createClass(NodeRectBase, [{
+    key: "getDefinition",
+    value: function getDefinition() {
+      return {
+        VERTICES: 6,
+        VERTEX_SHADER_SOURCE: SHADER_SOURCE,
+        FRAGMENT_SHADER_SOURCE: SHADER_SOURCE$1,
+        METHOD: WebGLRenderingContext.TRIANGLES,
+        UNIFORMS: UNIFORMS,
+        ATTRIBUTES: [{
+          name: "a_position",
+          size: 2,
+          type: FLOAT
+        }, {
+          name: "a_size",
+          size: 1,
+          type: FLOAT
+        }, {
+          name: "a_border",
+          size: 1,
+          type: FLOAT
+        }, {
+          name: "a_opacity",
+          size: 1,
+          type: FLOAT
+        }, {
+          name: "a_base",
+          size: 4,
+          type: UNSIGNED_BYTE,
+          normalized: true
+        }, {
+          name: "a_color",
+          size: 4,
+          type: UNSIGNED_BYTE,
+          normalized: true
+        }, {
+          name: "a_stroke",
+          size: 4,
+          type: UNSIGNED_BYTE,
+          normalized: true
+        }, {
+          name: "a_segments",
+          size: 1,
+          type: FLOAT
+        }].concat(_toConsumableArray(Array(7).fill(0).map(function (_, idx) {
+          return {
+            name: "a_colors_" + idx,
+            size: 4,
+            type: UNSIGNED_BYTE,
+            normalized: true
+          };
+        })), [{
+          name: "a_id",
+          size: 4,
+          type: UNSIGNED_BYTE,
+          normalized: true
+        }]),
+        CONSTANT_ATTRIBUTES: [{
+          name: "a_angle",
+          size: 1,
+          type: FLOAT
+        }],
+        CONSTANT_DATA: [[PI / 4], [3 * PI / 4], [-PI / 4], [3 * PI / 4], [-PI / 4], [-3 * PI / 4]]
+      };
+    }
+  }, {
+    key: "processVisibleItem",
+    value: function processVisibleItem(nodeIndex, startIndex, data) {
+      var _data$color, _data$borderColor, _data$border, _data$opacity, _data$pie$length, _data$pie;
+      var array = this.array;
+      var base = floatColor(this.renderer.getSetting("defaultNodeColor"));
+      var color = floatColor((_data$color = data.color) !== null && _data$color !== void 0 ? _data$color : this.renderer.getSetting("defaultNodeColor"));
+      var stroke = floatColor((_data$borderColor = data.borderColor) !== null && _data$borderColor !== void 0 ? _data$borderColor : this.renderer.getSetting("defaultEdgeColor"));
+      array[startIndex++] = data.x;
+      array[startIndex++] = data.y;
+      array[startIndex++] = data.size;
+      array[startIndex++] = Math.min((_data$border = data.border) !== null && _data$border !== void 0 ? _data$border : 0, 4);
+      array[startIndex++] = (_data$opacity = data.opacity) !== null && _data$opacity !== void 0 ? _data$opacity : 1;
+      array[startIndex++] = base;
+      array[startIndex++] = color;
+      array[startIndex++] = stroke;
+      array[startIndex++] = Math.min(7, (_data$pie$length = (_data$pie = data.pie) === null || _data$pie === void 0 ? void 0 : _data$pie.length) !== null && _data$pie$length !== void 0 ? _data$pie$length : 0);
+      Array(7).fill(0).forEach(function (_, idx) {
+        var _data$pie$idx, _data$pie2;
+        array[startIndex++] = floatColor((_data$pie$idx = (_data$pie2 = data.pie) === null || _data$pie2 === void 0 ? void 0 : _data$pie2[idx]) !== null && _data$pie$idx !== void 0 ? _data$pie$idx : "#0000");
+      });
+      array[startIndex++] = nodeIndex;
+    }
+  }, {
+    key: "setUniforms",
+    value: function setUniforms(params, _ref) {
+      var gl = _ref.gl,
+        uniformLocations = _ref.uniformLocations;
+      var u_sizeRatio = uniformLocations.u_sizeRatio,
+        u_correctionRatio = uniformLocations.u_correctionRatio,
+        u_cameraAngle = uniformLocations.u_cameraAngle,
+        u_matrix = uniformLocations.u_matrix;
+      gl.uniform1f(u_sizeRatio, params.sizeRatio);
+      gl.uniform1f(u_cameraAngle, params.cameraAngle);
+      gl.uniform1f(u_correctionRatio, params.correctionRatio);
+      gl.uniformMatrix3fv(u_matrix, false, params.matrix);
+    }
+  }]);
+}(NodeProgram);
+
+export { NodeRectBase };

package/dist/esm/packages/graph/src/programs/node-rect/base/vert.glsl.js

@@ -0,0 +1,8 @@
+'use client';
+
+/* istanbul ignore file */
+
+// language=GLSL
+var SHADER_SOURCE = /* glsl */"\nattribute vec4 a_id;\nattribute vec4 a_base;\nattribute vec4 a_color;\nattribute vec4 a_stroke;\nattribute vec2 a_position;\nattribute float a_size;\nattribute float a_border;\nattribute float a_angle;\nattribute float a_opacity;\nattribute float a_segments;\nattribute vec4 a_colors_0;\nattribute vec4 a_colors_1;\nattribute vec4 a_colors_2;\nattribute vec4 a_colors_3;\nattribute vec4 a_colors_4;\nattribute vec4 a_colors_5;\nattribute vec4 a_colors_6;\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_cameraAngle;\nuniform float u_correctionRatio;\n\nvarying vec4 v_color;\nvarying vec4 v_stroke;\nvarying float v_border;\nvarying vec2 v_diffVector;\nvarying float v_segmentAngle;\nvarying vec4 v_colors_0;\nvarying vec4 v_colors_1;\nvarying vec4 v_colors_2;\nvarying vec4 v_colors_3;\nvarying vec4 v_colors_4;\nvarying vec4 v_colors_5;\nvarying vec4 v_colors_6;\n\nconst float bias = 255.0 / 254.0;\nconst float sqrt_8 = sqrt(8.0);\n\nvoid main() {\n  float angle = a_angle + u_cameraAngle; \n\n  float size = a_size * u_correctionRatio / u_sizeRatio * sqrt_8;\n  vec2 diffVector = size * vec2(cos(angle), sin(angle));\n  vec2 position = a_position + diffVector;\n\n  float borderLessSize = (a_size - a_border) * u_correctionRatio / u_sizeRatio * sqrt_8;\n\n  gl_Position = vec4(\n    (u_matrix * vec3(position, 1)).xy,\n    0,\n    1\n  );\n\n  v_diffVector = diffVector;\n  v_border = a_border * u_correctionRatio / u_sizeRatio * sqrt_8;\n  v_border = borderLessSize / ".concat(Math.PI / 2.2, ";\n\n  #ifdef PICKING_MODE\n    v_color = a_id;\n  #else\n    v_color = mix(a_base, a_color, a_opacity * bias);\n    v_stroke = mix(a_base, a_stroke, a_opacity * bias);\n\n    // pie colors\n    v_segmentAngle = 0.0;\n    if(a_segments > 0.0) {\n      v_segmentAngle = ").concat(Math.PI * 2, " / a_segments;\n      v_colors_0 = mix(a_base, a_colors_0, a_opacity * bias);\n      v_colors_1 = mix(a_base, a_colors_1, a_opacity * bias);\n      v_colors_2 = mix(a_base, a_colors_2, a_opacity * bias);\n      v_colors_3 = mix(a_base, a_colors_3, a_opacity * bias);\n      v_colors_4 = mix(a_base, a_colors_4, a_opacity * bias);\n      v_colors_5 = mix(a_base, a_colors_5, a_opacity * bias);\n      v_colors_6 = mix(a_base, a_colors_6, a_opacity * bias);\n    }\n  #endif\n\n  v_color.a *= bias;\n}\n");
+
+export { SHADER_SOURCE as default };

package/dist/esm/packages/graph/src/programs/node-rect/index.js

@@ -0,0 +1,15 @@
+'use client';
+
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { createNodeCompoundProgram } from 'sigma/rendering';
+import { NodeBadgeProgram } from '../node-badge/index.js';
+import { NodeImageProgram } from '../node-image/index.js';
+import { NodeRectBase } from './base/index.js';
+import { drawNodeHover } from './base/drawHover.js';
+import { drawNodeLabel } from './base/drawLabel.js';
+
+/* istanbul ignore file */
+
+var NodeRectProgram = createNodeCompoundProgram([NodeRectBase, NodeImageProgram(false)].concat(_toConsumableArray(NodeBadgeProgram(false))), drawNodeLabel, drawNodeHover);
+
+export { NodeRectProgram };

package/dist/types/components/Context.d.ts

@@ -0,0 +1,18 @@
+import { PropsWithChildren } from "react";
+import { Graph } from "../graph";
+import { useDragSelection } from "../hooks/sigmaDragSelect";
+import { useSigma } from "../hooks/useSigma";
+import { EdgeAttributes, GraphProps, NodeAttributes } from "../types";
+interface Context<N = KeyValue, E = KeyValue> {
+    sigma: ReturnType<typeof useSigma>;
+    graph: Graph<NodeAttributes<N>, EdgeAttributes<E>>;
+    selected: string[];
+    layoutRunning: boolean;
+    dragSelector: ReturnType<typeof useDragSelection>;
+    resetViewport: () => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+}
+export declare const useGraph: <N = KeyValue, E = KeyValue>() => Context<N, E>;
+export declare const GraphProvider: <N = KeyValue, E = KeyValue>({ ref, data, children, nodeReducer, edgeReducer, onSelectChange, onNodeDoubleClick, onContextMenu, }: PropsWithChildren<GraphProps<N, E>>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/ContextMenu.d.ts

@@ -0,0 +1 @@
+export declare const GraphContextMenu: () => false | import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Tools.d.ts

@@ -0,0 +1 @@
+export declare const Tools: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Viewer.d.ts

@@ -0,0 +1,2 @@
+import { GraphProps } from "../types";
+export declare const SigmaGraph: <N = KeyValue, E = KeyValue>(props: GraphProps<N, E>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/constants/index.d.ts

@@ -0,0 +1,12 @@
+export declare const ICONS: {
+    focus: string;
+    zoomIn: string;
+    zoomOut: string;
+    lasso: string;
+    select: string;
+    cancel: string;
+    delete: string;
+    clear: string;
+    expand: string;
+    collapse: string;
+};

package/dist/types/graph/index.d.ts

@@ -0,0 +1,30 @@
+import Graphology from "graphology";
+import { GraphEvents, GraphOptions } from "graphology-types";
+import { EdgeAttributes, InternalNodeAttributes, NodeAttributes, RawGraph } from "../types";
+interface ExtendedEvents extends GraphEvents {
+    nodesLoaded: (nodes: string[]) => void;
+    nodesDropped: (nodes: string[]) => void;
+    nodesSelected: (nodes: string[]) => void;
+    layoutRunning: (isRunning: boolean) => void;
+    layoutDone: () => void;
+}
+export declare class Graph<N = KeyValue, E = KeyValue> extends Graphology<InternalNodeAttributes<N>, EdgeAttributes<E>, KeyValue> {
+    constructor(options?: GraphOptions);
+    on<Event extends keyof ExtendedEvents>(type: Event, listener: ExtendedEvents[Event]): this;
+    off<Event extends keyof ExtendedEvents>(type: Event, listener: ExtendedEvents[Event]): this;
+    emit<Event extends keyof ExtendedEvents>(type: Event, ...args: Parameters<ExtendedEvents[Event]>): boolean;
+    mergeNodes(key: string, nodes: string[], attributesOrNodeReducer?: NodeAttributes<N> | ((attributes: NodeAttributes<N>[]) => NodeAttributes<N>), edgeReducer?: (edges: RawGraph<N, E>["edges"]) => RawGraph<N, E>["edges"]): this | undefined;
+    groupNodes(key: string, nodes: string[], attributesOrNodeReducer?: NodeAttributes<N> | ((attributes: NodeAttributes<N>[]) => NodeAttributes<N>), edgeReducer?: (edges: RawGraph<N, E>["edges"]) => RawGraph<N, E>["edges"]): this | undefined;
+    ungroupNode(node: string): this | undefined;
+    toggleExpanded(node: string, force?: boolean): this;
+    import(data: RawGraph<N, E> | Graph<N, E>, merge?: boolean): this;
+    private elk;
+    elkLayout(type: string): Promise<void>;
+    dropNodes(nodes: string[]): void;
+    /**
+     * parallel edge check to be called after adding edges
+     */
+    private getCurvature;
+    private checkParallelEdges;
+}
+export {};

package/dist/types/graph/layout.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/hooks/sigmaDragSelect.d.ts

@@ -0,0 +1,8 @@
+import type Sigma from "sigma";
+import { type EdgeAttributes, type NodeAttributes } from "../types";
+export declare const useDragSelection: (renderer?: Sigma<NodeAttributes<any>, EdgeAttributes<any>>) => {
+    selectionMode: false | "rectangle" | "lasso";
+    startRectangleSelection: () => void;
+    startLassoSelection: () => void;
+    cancelSelection: () => void;
+};

package/dist/types/hooks/sigmaHilighter.d.ts

@@ -0,0 +1,3 @@
+import type Sigma from "sigma";
+import { EdgeAttributes, NodeAttributes } from "../types";
+export declare const attachHighlighter: (renderer: Sigma<NodeAttributes<any>, EdgeAttributes<any>>) => void;

package/dist/types/hooks/sigmaMouseActions.d.ts

@@ -0,0 +1,3 @@
+import type Sigma from "sigma";
+import { EdgeAttributes, NodeAttributes } from "../types";
+export declare const attachMouseActions: (renderer: Sigma<NodeAttributes<any>, EdgeAttributes<any>>) => void;

package/dist/types/hooks/useGraphology.d.ts

@@ -0,0 +1,6 @@
+import { Graph } from "../graph";
+import { GraphProps } from "../types";
+export declare const useGraphology: <N, E>(data: GraphProps<N, E>["data"]) => {
+    graph: Graph<N, E>;
+    selected: string[];
+};

package/dist/types/hooks/useSigma.d.ts

@@ -0,0 +1,8 @@
+import Sigma from "sigma";
+import { Graph } from "../graph";
+import { EdgeAttributes, NodeAttributes } from "../types";
+export declare const useSigma: <N, E>(graph: Graph<N, E>, nodeReducer?: (node: NodeAttributes<N>) => NodeAttributes<N>, edgeReducer?: (edge: EdgeAttributes<E>) => EdgeAttributes<E>) => {
+    instance: Sigma<NodeAttributes<N>, EdgeAttributes<E>, import("graphology-types").Attributes> | undefined;
+    containerRef: import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
+    componentsRef: import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { SigmaGraph } from "./components/Viewer";
+export { Graph } from "./graph";
+export type { EdgeAttributes, GraphRef, NodeAttributes, RawGraph, } from "./types";

package/dist/types/programs/arrow-head/frag.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER_SOURCE = "\nprecision mediump float;\n\nvarying vec4 v_color;\nvarying float v_opacity;\n\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nvoid main(void) {\n  gl_FragColor = v_color;\n  gl_FragColor = mix(transparent, gl_FragColor, v_opacity);\n}\n";
+export default SHADER_SOURCE;

package/dist/types/programs/arrow-head/index.d.ts

@@ -0,0 +1,9 @@
+import { Attributes } from "graphology-types";
+import { EdgeProgramType } from "sigma/rendering";
+export type CreateEdgeArrowHeadProgramOptions = {
+    extremity: "source" | "target";
+    lengthToThicknessRatio: number;
+    widenessToThicknessRatio: number;
+};
+export declare const DEFAULT_EDGE_ARROW_HEAD_PROGRAM_OPTIONS: CreateEdgeArrowHeadProgramOptions;
+export declare function createEdgeArrowHeadProgram<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes>(inputOptions?: Partial<CreateEdgeArrowHeadProgramOptions>): EdgeProgramType<N, E, G>;

package/dist/types/programs/arrow-head/vert.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER_SOURCE = "\nattribute vec2 a_position;\nattribute vec2 a_normal;\nattribute float a_radius;\nattribute vec3 a_barycentric;\nattribute float a_opacity;\n\n#ifdef PICKING_MODE\nattribute vec4 a_id;\n#else\nattribute vec4 a_color;\n#endif\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_correctionRatio;\nuniform float u_minEdgeThickness;\nuniform float u_lengthToThicknessRatio;\nuniform float u_widenessToThicknessRatio;\n\nvarying vec4 v_color;\nvarying float v_opacity;\n\nconst float bias = 255.0 / 254.0;\n\nvoid main() {\n  float minThickness = u_minEdgeThickness;\n\n  float normalLength = length(a_normal);\n  vec2 unitNormal = a_normal / normalLength;\n\n  // These first computations are taken from edge.vert.glsl and\n  // edge.clamped.vert.glsl. Please read it to get better comments on what's\n  // happening:\n  float pixelsThickness = max(normalLength / u_sizeRatio, minThickness);\n  float webGLThickness = pixelsThickness * u_correctionRatio;\n  float webGLNodeRadius = a_radius * 2.0 * u_correctionRatio / u_sizeRatio;\n  float webGLArrowHeadLength = webGLThickness * u_lengthToThicknessRatio * 2.0;\n  float webGLArrowHeadThickness = webGLThickness * u_widenessToThicknessRatio;\n\n  float da = a_barycentric.x;\n  float db = a_barycentric.y;\n  float dc = a_barycentric.z;\n\n  vec2 delta = vec2(\n      da * (webGLNodeRadius * unitNormal.y)\n    + db * ((webGLNodeRadius + webGLArrowHeadLength) * unitNormal.y + webGLArrowHeadThickness * unitNormal.x)\n    + dc * ((webGLNodeRadius + webGLArrowHeadLength) * unitNormal.y - webGLArrowHeadThickness * unitNormal.x),\n\n      da * (-webGLNodeRadius * unitNormal.x)\n    + db * (-(webGLNodeRadius + webGLArrowHeadLength) * unitNormal.x + webGLArrowHeadThickness * unitNormal.y)\n    + dc * (-(webGLNodeRadius + webGLArrowHeadLength) * unitNormal.x - webGLArrowHeadThickness * unitNormal.y)\n  );\n\n  vec2 position = (u_matrix * vec3(a_position + delta, 1)).xy;\n\n  gl_Position = vec4(position, 0, 1);\n\n  #ifdef PICKING_MODE\n  // For picking mode, we use the ID as the color:\n  v_color = a_id;\n  #else\n  // For normal mode, we use the color:\n  v_color = a_color;\n  v_opacity = a_opacity;\n  #endif\n\n  v_color.a *= bias;\n}\n";
+export default SHADER_SOURCE;

package/dist/types/programs/edge-curve/drawLabel.d.ts

@@ -0,0 +1,6 @@
+import { type CreateEdgeCurveProgramOptions } from "@sigma/edge-curve/dist/declarations/src/utils";
+import { type Attributes } from "graphology-types";
+import { type EdgeLabelDrawingFunction } from "sigma/rendering";
+export declare function createDrawCurvedEdgeLabel<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes>({ curvatureAttribute, defaultCurvature, keepLabelUpright, }: CreateEdgeCurveProgramOptions & {
+    keepLabelUpright?: boolean;
+}): EdgeLabelDrawingFunction<N, E, G>;

package/dist/types/programs/edge-curve/frag.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER = "\nprecision highp float;\n\nvarying vec4 v_color;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\nvarying vec2 v_cpA;\nvarying vec2 v_cpB;\nvarying vec2 v_cpC;\nvarying float v_sourceSize;\nvarying vec2 v_sourcePoint;\nvarying float v_targetSize;\nvarying vec2 v_targetPoint;\n\nuniform float u_lengthToThicknessRatio;\nuniform float u_widenessToThicknessRatio;\n\nfloat det(vec2 a, vec2 b) {\n  return a.x * b.y - b.x * a.y;\n}\n\nvec2 getDistanceVector(vec2 b0, vec2 b1, vec2 b2) {\n  float a = det(b0, b2), b = 2.0 * det(b1, b0), d = 2.0 * det(b2, b1);\n  float f = b * d - a * a;\n  vec2 d21 = b2 - b1, d10 = b1 - b0, d20 = b2 - b0;\n  vec2 gf = 2.0 * (b * d21 + d * d10 + a * d20);\n  gf = vec2(gf.y, -gf.x);\n  vec2 pp = -f * gf / dot(gf, gf);\n  vec2 d0p = b0 - pp;\n  float ap = det(d0p, d20), bp = 2.0 * det(d10, d0p);\n  float t = clamp((ap + bp) / (2.0 * a + b + d), 0.0, 1.0);\n  return mix(mix(b0, b1, t), mix(b1, b2, t), t);\n}\n\nfloat distToQuadraticBezierCurve(vec2 p, vec2 b0, vec2 b1, vec2 b2) {\n  return length(getDistanceVector(b0 - p, b1 - p, b2 - p));\n}\n\nconst float epsilon = 0.7;\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nvoid main(void) {\n  float dist = distToQuadraticBezierCurve(gl_FragCoord.xy, v_cpA, v_cpB, v_cpC);\n  float thickness = v_thickness;\n\n  if(v_sourceSize > 0.0) {\n    float distToSource = length(gl_FragCoord.xy - v_sourcePoint);\n    float sourceArrowLength = v_sourceSize + (thickness) * u_lengthToThicknessRatio;\n    if (distToSource < sourceArrowLength) {\n      thickness = (distToSource - v_sourceSize) / (sourceArrowLength - v_sourceSize) * u_widenessToThicknessRatio * thickness;\n    }\n  }\n\n  if(v_targetSize > 0.0) {\n    float distToTarget = length(gl_FragCoord.xy - v_targetPoint);\n    float targetArrowLength = v_targetSize + (thickness) * u_lengthToThicknessRatio;\n    if (distToTarget < targetArrowLength) {\n      thickness = (distToTarget - v_targetSize) / (targetArrowLength - v_targetSize) * u_widenessToThicknessRatio * thickness;\n    }\n  }\n\n  float halfThickness = thickness / 2.0;\n  if (dist < halfThickness) {\n    #ifdef PICKING_MODE\n    gl_FragColor = v_color;\n    #else\n    float t = smoothstep(\n      halfThickness - v_feather,\n      halfThickness,\n      dist\n    );\n\n    gl_FragColor = mix(v_color, transparent, t);\n    gl_FragColor = mix(transparent, gl_FragColor, v_opacity);\n    #endif\n  } else {\n    gl_FragColor = transparent;\n  }\n}\n";
+export default SHADER;

package/dist/types/programs/edge-curve/index.d.ts

@@ -0,0 +1,43 @@
+import { type Attributes } from "graphology-types";
+import { EdgeProgram, type ProgramInfo } from "sigma/rendering";
+import { type EdgeDisplayData, type NodeDisplayData, type RenderParams } from "sigma/types";
+import { InternalEdgeAttributes } from "../../types";
+declare const UNIFORMS: readonly ["u_matrix", "u_sizeRatio", "u_dimensions", "u_pixelRatio", "u_feather", "u_minEdgeThickness", "u_lengthToThicknessRatio", "u_widenessToThicknessRatio"];
+export declare class EdgeCurveProgramBase<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes> extends EdgeProgram<(typeof UNIFORMS)[number], N, E, G> {
+    getDefinition(): {
+        VERTICES: number;
+        VERTEX_SHADER_SOURCE: string;
+        FRAGMENT_SHADER_SOURCE: string;
+        METHOD: 4;
+        UNIFORMS: readonly ["u_matrix", "u_sizeRatio", "u_dimensions", "u_pixelRatio", "u_feather", "u_minEdgeThickness", "u_lengthToThicknessRatio", "u_widenessToThicknessRatio"];
+        ATTRIBUTES: ({
+            name: string;
+            size: number;
+            type: 5126;
+            normalized?: undefined;
+        } | {
+            name: string;
+            size: number;
+            type: 5121;
+            normalized: boolean;
+        })[];
+        CONSTANT_ATTRIBUTES: {
+            name: string;
+            size: number;
+            type: 5126;
+        }[];
+        CONSTANT_DATA: number[][];
+    };
+    processVisibleItem(edgeIndex: number, startIndex: number, sourceData: NodeDisplayData, targetData: NodeDisplayData, data: EdgeDisplayData & InternalEdgeAttributes): void;
+    setUniforms(params: RenderParams, { gl, uniformLocations }: ProgramInfo): void;
+}
+export declare const EdgeCurveProgram: {
+    new (_gl: WebGLRenderingContext, _pickingBuffer: WebGLFramebuffer | null, _renderer: import("sigma").default<Attributes, Attributes, Attributes>): {
+        drawLabel: import("sigma/rendering").EdgeLabelDrawingFunction<Attributes, Attributes, Attributes> | undefined;
+        kill(): void;
+        reallocate(_capacity: number): void;
+        process(_edgeIndex: number, _offset: number, _sourceData: NodeDisplayData, _targetData: NodeDisplayData, _data: EdgeDisplayData): void;
+        render(_params: RenderParams): void;
+    };
+};
+export {};

package/dist/types/programs/edge-curve/vert.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER = "\nattribute vec4 a_id;\nattribute vec4 a_color;\nattribute float a_direction;\nattribute float a_thickness;\nattribute float a_opacity;\nattribute vec2 a_source;\nattribute vec2 a_target;\nattribute float a_current;\nattribute float a_curvature;\nattribute float a_sourceSize;\nattribute float a_targetSize;\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_pixelRatio;\nuniform vec2 u_dimensions;\nuniform float u_minEdgeThickness;\nuniform float u_feather;\nuniform float u_widenessToThicknessRatio;\n\nvarying vec4 v_color;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\nvarying vec2 v_cpA;\nvarying vec2 v_cpB;\nvarying vec2 v_cpC;\nvarying float v_sourceSize;\nvarying vec2 v_sourcePoint;\nvarying float v_targetSize;\nvarying vec2 v_targetPoint;\n\nconst float bias = 255.0 / 254.0;\nconst float epsilon = 0.7;\n\nvec2 clipspaceToViewport(vec2 pos, vec2 dimensions) {\n  return vec2(\n    (pos.x + 1.0) * dimensions.x / 2.0,\n    (pos.y + 1.0) * dimensions.y / 2.0\n  );\n}\n\nvec2 viewportToClipspace(vec2 pos, vec2 dimensions) {\n  return vec2(\n    pos.x / dimensions.x * 2.0 - 1.0,\n    pos.y / dimensions.y * 2.0 - 1.0\n  );\n}\n\nvoid main() {\n  float minThickness = u_minEdgeThickness;\n  // Selecting the correct position\n  // Branchless \"position = a_source if a_current == 1.0 else a_target\"\n  vec2 position = a_source * max(0.0, a_current) + a_target * max(0.0, 1.0 - a_current);\n  position = (u_matrix * vec3(position, 1)).xy;\n\n  vec2 source = (u_matrix * vec3(a_source, 1)).xy;\n  vec2 target = (u_matrix * vec3(a_target, 1)).xy;\n\n  vec2 viewportPosition = clipspaceToViewport(position, u_dimensions);\n  vec2 viewportSource = clipspaceToViewport(source, u_dimensions);\n  vec2 viewportTarget = clipspaceToViewport(target, u_dimensions);\n\n  vec2 delta = viewportTarget.xy - viewportSource.xy;\n  float len = length(delta);\n  vec2 normal = vec2(-delta.y, delta.x) * a_direction;\n  vec2 unitNormal = normal / len;\n  float boundingBoxThickness = len * a_curvature;\n  float curveThickness = max(minThickness, a_thickness / 2.0 / u_sizeRatio * u_pixelRatio);\n\n  v_thickness = curveThickness;\n  v_feather = u_feather;\n\n  v_cpA = viewportSource;\n  v_cpB = 0.5 * (viewportSource + viewportTarget) + unitNormal * a_direction * boundingBoxThickness;\n  v_cpC = viewportTarget;\n\n  vec2 viewportOffsetPosition = (\n    viewportPosition +\n    unitNormal * (boundingBoxThickness / 2.0 + sign(boundingBoxThickness) * (curveThickness + epsilon)) *\n    max(0.0, a_direction) // NOTE: cutting the bounding box in half to avoid overdraw\n  );\n\n  position = viewportToClipspace(viewportOffsetPosition, u_dimensions);\n  gl_Position = vec4(position, 0, 1);\n\n  v_sourceSize = a_sourceSize * u_pixelRatio / u_sizeRatio;\n  v_sourcePoint = viewportSource;\n  \n  v_targetSize = a_targetSize * u_pixelRatio / u_sizeRatio;\n  v_targetPoint = viewportTarget;\n    \n  #ifdef PICKING_MODE\n  // For picking mode, we use the ID as the color:\n  v_color = a_id;\n  #else\n  // For normal mode, we use the color:\n  v_color = a_color;\n  v_opacity = a_opacity;\n  #endif\n\n  v_color.a *= bias;\n}\n";
+export default SHADER;

package/dist/types/programs/edge-line/drawLabel.d.ts

@@ -0,0 +1,5 @@
+import { type Attributes } from "graphology-types";
+import { type Settings } from "sigma/settings";
+import { type EdgeDisplayData, type NodeDisplayData, type PartialButFor } from "sigma/types";
+export type EdgeLabelDrawingFunction<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes> = (context: CanvasRenderingContext2D, edgeData: PartialButFor<EdgeDisplayData, "label" | "color" | "size">, sourceData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, targetData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, settings: Settings<N, E, G>) => void;
+export declare function drawLineLabel<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes>(context: CanvasRenderingContext2D, edgeData: PartialButFor<EdgeDisplayData, "label" | "color" | "size">, sourceData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, targetData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, settings: Settings<N, E, G>): void;

package/dist/types/programs/edge-line/frag.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER_SOURCE = "\nprecision mediump float;\n\nvarying vec4 v_color;\nvarying vec2 v_normal;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\n\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nvoid main(void) {\n  // We only handle antialiasing for normal mode:\n  #ifdef PICKING_MODE\n  gl_FragColor = v_color;\n  #else\n  float dist = length(v_normal) * v_thickness;\n\n  float t = smoothstep(\n    v_thickness - v_feather,\n    v_thickness,\n    dist\n  );\n\n  gl_FragColor = mix(v_color, transparent, t);\n  gl_FragColor = mix(transparent, gl_FragColor, v_opacity);\n  #endif\n}\n";
+export default SHADER_SOURCE;

package/dist/types/programs/edge-line/index.d.ts

@@ -0,0 +1,11 @@
+import { type Attributes } from "graphology-types";
+import { type EdgeDisplayData, type NodeDisplayData, type RenderParams } from "sigma/types";
+export declare const EdgeLineProgram: {
+    new (_gl: WebGLRenderingContext, _pickingBuffer: WebGLFramebuffer | null, _renderer: import("sigma").default<Attributes, Attributes, Attributes>): {
+        drawLabel: import("sigma/rendering").EdgeLabelDrawingFunction<Attributes, Attributes, Attributes> | undefined;
+        kill(): void;
+        reallocate(_capacity: number): void;
+        process(_edgeIndex: number, _offset: number, _sourceData: NodeDisplayData, _targetData: NodeDisplayData, _data: EdgeDisplayData): void;
+        render(_params: RenderParams): void;
+    };
+};

package/dist/types/programs/edge-line/vert.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER_SOURCE = "\nattribute vec4 a_id;\nattribute vec4 a_color;\nattribute vec2 a_normal;\nattribute float a_opacity;\nattribute float a_normalCoef;\nattribute vec2 a_positionStart;\nattribute vec2 a_positionEnd;\nattribute float a_positionCoef;\nattribute float a_sourceRadius;\nattribute float a_targetRadius;\nattribute float a_sourceRadiusCoef;\nattribute float a_targetRadiusCoef;\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_zoomRatio;\nuniform float u_pixelRatio;\nuniform float u_correctionRatio;\nuniform float u_minEdgeThickness;\nuniform float u_lengthToThicknessRatio;\nuniform float u_feather;\n\nvarying vec4 v_color;\nvarying vec2 v_normal;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\n\nconst float minThickness = 1.7;\nconst float bias = 255.0 / 254.0;\n\nvoid main() {\n  vec2 normal = a_normal * a_normalCoef;\n  vec2 position = a_positionStart * (1.0 - a_positionCoef) + a_positionEnd * a_positionCoef;\n\n  float normalLength = length(normal);\n  vec2 unitNormal = normal / normalLength;\n\n  // We require edges to be at least \"minThickness\" pixels thick *on screen*\n  // (so we need to compensate the size ratio):\n  float pixelsThickness = max(normalLength, minThickness * u_sizeRatio);\n\n  // Then, we need to retrieve the normalized thickness of the edge in the WebGL\n  // referential (in a ([0, 1], [0, 1]) space), using our \"magic\" correction\n  // ratio:\n  float webGLThickness = pixelsThickness * u_correctionRatio / u_sizeRatio;\n\n  // Here, we move the point to leave space for the arrow heads:\n  // Source arrow head\n  float sourceRadius = a_sourceRadius * a_sourceRadiusCoef;\n  float sourceDirection = sign(sourceRadius);\n  float webGLSourceRadius = sourceDirection * sourceRadius * 2.0 * u_correctionRatio / u_sizeRatio;\n  float webGLSourceArrowHeadLength = webGLThickness * u_lengthToThicknessRatio * 2.0;\n  vec2 sourceCompensationVector =\n    vec2(-sourceDirection * unitNormal.y, sourceDirection * unitNormal.x)\n    * (webGLSourceRadius + webGLSourceArrowHeadLength);\n    \n  // Target arrow head\n  float targetRadius = a_targetRadius * a_targetRadiusCoef;\n  float targetDirection = sign(targetRadius);\n  float webGLTargetRadius = targetDirection * targetRadius * 2.0 * u_correctionRatio / u_sizeRatio;\n  float webGLTargetArrowHeadLength = webGLThickness * u_lengthToThicknessRatio * 2.0;\n  vec2 targetCompensationVector =\n  vec2(-targetDirection * unitNormal.y, targetDirection * unitNormal.x)\n    * (webGLTargetRadius + webGLTargetArrowHeadLength);\n\n  if(a_sourceRadius == 0.0) {\n    sourceCompensationVector = vec2(0.0, 0.0);\n  }\n  if(a_targetRadius == 0.0) {\n    targetCompensationVector = vec2(0.0, 0.0);\n  }\n\n  // Here is the proper position of the vertex\n  gl_Position = vec4((u_matrix * vec3(position + unitNormal * webGLThickness + sourceCompensationVector + targetCompensationVector, 1)).xy, 0, 1);\n\n  // For the fragment shader though, we need a thickness that takes the \"magic\"\n  // correction ratio into account (as in webGLThickness), but so that the\n  // antialiasing effect does not depend on the zoom level. So here's yet\n  // another thickness version:\n  v_thickness = webGLThickness / u_zoomRatio;\n\n  v_normal = unitNormal;\n\n  v_feather = u_feather * u_correctionRatio / u_zoomRatio / u_pixelRatio * 2.0;\n\n  #ifdef PICKING_MODE\n  // For picking mode, we use the ID as the color:\n  v_color = a_id;\n  #else\n  // For normal mode, we use the color:\n  v_color = a_color;\n  v_opacity = a_opacity;\n  #endif\n\n  v_color.a *= bias;\n}\n";
+export default SHADER_SOURCE;

package/dist/types/programs/node-badge/factory.d.ts

@@ -0,0 +1,27 @@
+import { type Attributes } from "graphology-types";
+import { type NodeHoverDrawingFunction, type NodeLabelDrawingFunction, type NodeProgramType } from "sigma/rendering";
+import { type EdgeAttributes, type NodeAttributes } from "../../types";
+import { type TextureManagerOptions } from "./texture";
+interface CreateNodeImageProgramOptions<N extends Attributes, E extends Attributes, G extends Attributes> extends TextureManagerOptions {
+    drawingMode: "background" | "color";
+    keepWithinCircle: boolean;
+    drawLabel: NodeLabelDrawingFunction<N, E, G> | undefined;
+    drawHover: NodeHoverDrawingFunction<N, E, G> | undefined;
+    padding: number;
+    colorAttribute: string;
+}
+/**
+ * To share the texture between the program instances of the graph and the
+ * hovered nodes (to prevent some flickering, mostly), this program must be
+ * "built" for each sigma instance:
+ */
+export default function getNodeImageProgram(options?: Partial<CreateNodeImageProgramOptions<NodeAttributes & {
+    bg: string;
+    opacity: number;
+}, EdgeAttributes, Attributes>> & {
+    badgePosition: string;
+}): NodeProgramType<NodeAttributes & {
+    bg: string;
+    opacity: number;
+}, EdgeAttributes>;
+export {};

package/dist/types/programs/node-badge/frag.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER_SOURCE = "\nprecision highp float;\n\nvarying vec4 v_fill;\nvarying vec4 v_color;\nvarying vec4 v_texture;\nvarying vec2 v_diffVector;\nvarying float v_opacity;\nvarying float v_radius;\n\nuniform sampler2D u_atlas;\nuniform float u_correctionRatio;\nuniform float u_cameraAngle;\nuniform float u_percentagePadding;\nuniform bool u_keepWithinCircle;\nuniform bool u_shape;\n\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nconst float radius = 0.5;\n\nvoid main(void) {\n  float border = 2.0 * u_correctionRatio;\n  float dist = length(v_diffVector);\n  vec4 color = v_fill;\n\n  float c = cos(-u_cameraAngle);\n  float s = sin(-u_cameraAngle);\n  vec2 diffVector = mat2(c, s, -s, c) * (v_diffVector);\n\n  // No antialiasing for picking mode:\n  #ifdef PICKING_MODE\n  border = 0.0;\n  gl_FragColor = v_color;\n\n  #else\n  // First case: No image to display\n  if (v_texture.w <= 0.0) {\n     color = v_fill;\n  }\n\n  // Second case: Image loaded into the texture\n  else {\n    float paddingRatio = 1.0 + 2.0 * u_percentagePadding;\n    float coef = 1.0;\n    vec2 coordinateInTexture = diffVector * vec2(paddingRatio, -paddingRatio) / v_radius / 2.0 * coef + vec2(0.5, 0.5);\n    vec4 texel = texture2D(u_atlas, (v_texture.xy + coordinateInTexture * v_texture.zw), -1.0);\n\n    // Colorize all visible image pixels:\n    color = mix(v_fill, v_color, texel.a);\n    \n    // Erase pixels \"in the padding\":\n    if (abs(diffVector.x) > v_radius / paddingRatio || abs(diffVector.y) > v_radius / paddingRatio) {\n      color = v_fill;\n    }\n  }\n\n  // Crop in a circle when u_keepWithinCircle is truthy:\n  if(v_opacity == 0.0) {\n    gl_FragColor = transparent;\n  }\n  else if (dist - v_radius + border > border)\n    gl_FragColor = transparent;\n  else if (dist - v_radius + border > 0.0) {\n    gl_FragColor = mix(v_fill, transparent, (dist - v_radius + border) / border);\n  }\n  else  {\n    gl_FragColor = mix(v_fill, color, v_opacity);\n  }\n  #endif\n  \n\n}\n";
+export default SHADER_SOURCE;

package/dist/types/programs/node-badge/index.d.ts

@@ -0,0 +1,5 @@
+export { default as createNodeImageProgram } from "./factory";
+export declare const NodeBadgeProgram: (isCircle: boolean) => import("sigma/rendering").NodeProgramType<import("../..").NodeAttributes<KeyValue<any>> & {
+    bg: string;
+    opacity: number;
+}, import("../..").EdgeAttributes<KeyValue<any>>>[];

package/dist/types/programs/node-badge/texture.d.ts

@@ -0,0 +1,102 @@
+import { EventEmitter } from "events";
+import { type Coordinates } from "sigma/types";
+/**
+ * Useful types:
+ * *************
+ */
+export interface ImageLoading {
+    status: "loading";
+}
+export interface ImageError {
+    status: "error";
+}
+export interface ImageReady {
+    status: "ready";
+    image: HTMLImageElement;
+    sourceX: number;
+    sourceY: number;
+    sourceSize: number;
+    destinationSize: number;
+}
+export type ImageType = ImageLoading | ImageError | ImageReady;
+export type Atlas = Record<string, Coordinates & {
+    size: number;
+}>;
+export interface TextureManagerOptions {
+    size: {
+        mode: "auto";
+    } | {
+        mode: "max";
+        value: number;
+    } | {
+        mode: "force";
+        value: number;
+    };
+    objectFit: "contain" | "cover" | "fill";
+    correctCentering: boolean;
+}
+export declare const DEFAULT_TEXTURE_MANAGER_OPTIONS: TextureManagerOptions;
+export declare const DEBOUNCE_TIMEOUT = 100;
+export declare const MARGIN_IN_TEXTURE = 1;
+/**
+ * Helpers:
+ * ********
+ */
+/**
+ * This helper loads an image at a given URL, and returns an HTMLImageElement
+ * with it displayed once it's properly loaded, within a promise.
+ */
+export declare function loadRasterImage(imageSource: string): Promise<HTMLImageElement>;
+export declare const makeSvg: (path?: string) => string;
+/**
+ * This helper loads an SVG image at a given URL, adjusts its size to a given
+ * size, and returns an HTMLImageElement with it displayed once it's properly
+ * loaded, within a promise.
+ */
+export declare function loadSVGImage(imageSource: string, { size }?: {
+    size?: number;
+}): Promise<HTMLImageElement>;
+/**
+ * This helper loads an image using the proper function.
+ */
+export declare function loadImage(imageSource: string, { size }?: {
+    size?: number;
+}): Promise<HTMLImageElement>;
+/**
+ * This helper computes exact coordinates to draw an image onto a texture.
+ */
+export declare function refineImage(image: HTMLImageElement, corrector: PictogramCenteringCorrector, { objectFit, size, correctCentering }: TextureManagerOptions): Omit<ImageReady, "status" | "image">;
+/**
+ * This helper takes a collection of image states and a context, draw all the
+ * images in the context, and returns an atlas to get where each image is drawn
+ * on the texture.
+ */
+export declare function drawTexture(ctx: CanvasRenderingContext2D, images: Record<string, ImageType>): Atlas;
+/**
+ * This class helps to "correct" the centering of an SVG pictogram by finding
+ * the "true" visually correct center through the barycenter of the pictogram's
+ * alpha layer in x and y dimension.
+ */
+export declare class PictogramCenteringCorrector {
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    constructor();
+    getCorrectionOffset(image: HTMLImageElement, size: number): Coordinates;
+}
+export declare class TextureManager extends EventEmitter {
+    static NEW_TEXTURE_EVENT: string;
+    private readonly options;
+    private readonly canvas;
+    private readonly ctx;
+    private frameId?;
+    private readonly corrector;
+    private imageStates;
+    private texture;
+    private atlas;
+    constructor(options?: Partial<TextureManagerOptions>);
+    private scheduleGenerateTexture;
+    private generateTexture;
+    registerImage(source: string): Promise<void>;
+    getAtlas(): Atlas;
+    getTexture(): ImageData;
+}

package/dist/types/programs/node-badge/vert.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const VERTEX_SHADER_SOURCE: string;
+export default VERTEX_SHADER_SOURCE;

package/dist/types/programs/node-circle/base/drawHover.d.ts

@@ -0,0 +1,8 @@
+import { type Settings } from "sigma/settings";
+import { EdgeAttributes, NodeAttributes } from "../../../types";
+export declare function drawNodeHover(context: CanvasRenderingContext2D, data: NodeAttributes & {
+    opacity: number;
+    x: number;
+    y: number;
+    size: number;
+}, settings: Settings<NodeAttributes, EdgeAttributes>): void;

package/dist/types/programs/node-circle/base/drawLabel.d.ts

@@ -0,0 +1,8 @@
+import { type Settings } from "sigma/settings";
+import { EdgeAttributes, InternalNodeAttributes, NodeAttributes } from "../../../types";
+export declare function drawNodeLabel(context: CanvasRenderingContext2D, data: InternalNodeAttributes & {
+    opacity: number;
+    x: number;
+    y: number;
+    size: number;
+}, settings: Settings<NodeAttributes, EdgeAttributes>): void;

package/dist/types/programs/node-circle/base/frag.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const SHADER_SOURCE: string;
+export default SHADER_SOURCE;

package/dist/types/programs/node-circle/base/index.d.ts

@@ -0,0 +1,37 @@
+import { NodeProgram, type ProgramInfo } from "sigma/rendering";
+import { type NodeDisplayData, type RenderParams } from "sigma/types";
+import { type EdgeAttributes, type NodeAttributes } from "../../../types";
+declare const UNIFORMS: readonly ["u_sizeRatio", "u_correctionRatio", "u_matrix"];
+export declare class NodeCircleBase extends NodeProgram<(typeof UNIFORMS)[number], NodeAttributes, EdgeAttributes> {
+    static readonly ANGLE_1 = 0;
+    static readonly ANGLE_2: number;
+    static readonly ANGLE_3: number;
+    getDefinition(): {
+        VERTICES: number;
+        VERTEX_SHADER_SOURCE: string;
+        FRAGMENT_SHADER_SOURCE: string;
+        METHOD: 4;
+        UNIFORMS: readonly ["u_sizeRatio", "u_correctionRatio", "u_matrix"];
+        ATTRIBUTES: ({
+            name: string;
+            size: number;
+            type: 5121;
+            normalized: boolean;
+        } | {
+            name: string;
+            size: number;
+            type: 5126;
+        })[];
+        CONSTANT_ATTRIBUTES: {
+            name: string;
+            size: number;
+            type: 5126;
+        }[];
+        CONSTANT_DATA: number[][];
+    };
+    processVisibleItem(nodeIndex: number, startIndex: number, data: NodeDisplayData & NodeAttributes & {
+        opacity: number;
+    }): void;
+    setUniforms(params: RenderParams, { gl, uniformLocations }: ProgramInfo): void;
+}
+export {};