@reltio/components 1.4.1844 → 1.4.1846

package/esm/features/graph/rendering/webgl/edge.arrowHead.js

@@ -0,0 +1,79 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/**
+ * This class extends src/rendering/webgl/programs/edge.arrowHead.ts for arrowSizeRatio support
+ */
+import SigmaEdgeArrowHeadProgram from 'sigma/rendering/webgl/programs/edge.arrowHead';
+import { floatColor } from 'sigma/utils';
+var POINTS = 3, ATTRIBUTES = 9, STRIDE = POINTS * ATTRIBUTES;
+var EdgeArrowHeadProgram = /** @class */ (function (_super) {
+    __extends(EdgeArrowHeadProgram, _super);
+    function EdgeArrowHeadProgram() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EdgeArrowHeadProgram.prototype.process = function (sourceData, targetData, data, hidden, offset) {
+        if (hidden) {
+            for (var i_1 = offset * STRIDE, l = i_1 + STRIDE; i_1 < l; i_1++)
+                this.array[i_1] = 0;
+            return;
+        }
+        // Our changes - added arrowSizeRatio support
+        var arrowSizeRatio = data.arrowSizeRatio || 1;
+        var thickness = data.size * arrowSizeRatio || 1, radius = targetData.size || 1, x1 = sourceData.x, y1 = sourceData.y, x2 = targetData.x, y2 = targetData.y, color = floatColor(data.color);
+        // Computing normals
+        var dx = x2 - x1, dy = y2 - y1;
+        var len = dx * dx + dy * dy, n1 = 0, n2 = 0;
+        if (len) {
+            len = 1 / Math.sqrt(len);
+            n1 = -dy * len * thickness;
+            n2 = dx * len * thickness;
+        }
+        var i = POINTS * ATTRIBUTES * offset;
+        var array = this.array;
+        // First point
+        array[i++] = x2;
+        array[i++] = y2;
+        array[i++] = -n1;
+        array[i++] = -n2;
+        array[i++] = radius;
+        array[i++] = color;
+        array[i++] = 1;
+        array[i++] = 0;
+        array[i++] = 0;
+        // Second point
+        array[i++] = x2;
+        array[i++] = y2;
+        array[i++] = -n1;
+        array[i++] = -n2;
+        array[i++] = radius;
+        array[i++] = color;
+        array[i++] = 0;
+        array[i++] = 1;
+        array[i++] = 0;
+        // Third point
+        array[i++] = x2;
+        array[i++] = y2;
+        array[i++] = -n1;
+        array[i++] = -n2;
+        array[i++] = radius;
+        array[i++] = color;
+        array[i++] = 0;
+        array[i++] = 0;
+        array[i] = 1;
+    };
+    return EdgeArrowHeadProgram;
+}(SigmaEdgeArrowHeadProgram));
+export default EdgeArrowHeadProgram;

package/esm/features/graph/rendering/webgl/edge.clamped.d.ts

@@ -0,0 +1,29 @@
+/**
+ * This class copies src/rendering/webgl/programs/edge.clamped.ts, but with a some difference:
+ * implemented arrowSizeRatio edge attribute, forwarded it to shaders as a_arrowSizeRatio
+ * implemented 'doubleArrow' edge type support
+ */
+import { AbstractEdgeProgram } from 'sigma/rendering/webgl/programs/common/edge';
+import { RenderParams } from 'sigma/rendering/webgl/programs/common/program';
+import { GraphEdgeAttributes, GraphNodeAttributes } from '../../types/graphDataTypes';
+export default class EdgeClampedProgram extends AbstractEdgeProgram {
+    IndicesArray: Uint32ArrayConstructor | Uint16ArrayConstructor;
+    indicesArray: Uint32Array | Uint16Array;
+    indicesBuffer: WebGLBuffer;
+    indicesType: GLenum;
+    positionLocation: GLint;
+    colorLocation: GLint;
+    normalLocation: GLint;
+    radiusLocation: GLint;
+    arrowSizeRatioLocation: GLint;
+    matrixLocation: WebGLUniformLocation;
+    sqrtZoomRatioLocation: WebGLUniformLocation;
+    correctionRatioLocation: WebGLUniformLocation;
+    canUse32BitsIndices: boolean;
+    constructor(gl: WebGLRenderingContext);
+    bind(): void;
+    process(sourceData: GraphNodeAttributes, targetData: GraphNodeAttributes, data: GraphEdgeAttributes, hidden: boolean, offset: number): void;
+    computeIndices(): void;
+    bufferData(): void;
+    render(params: RenderParams): void;
+}

package/esm/features/graph/rendering/webgl/edge.clamped.js

@@ -0,0 +1,171 @@
+/**
+ * This class copies src/rendering/webgl/programs/edge.clamped.ts, but with a some difference:
+ * implemented arrowSizeRatio edge attribute, forwarded it to shaders as a_arrowSizeRatio
+ * implemented 'doubleArrow' edge type support
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { floatColor, canUse32BitsIndices } from 'sigma/utils';
+import { AbstractEdgeProgram } from 'sigma/rendering/webgl/programs/common/edge';
+import fragmentShaderSource from 'sigma/rendering/webgl/shaders/edge.frag.glsl';
+import { vertexShaderSource } from './shaders/edge.clamped.vert.glsl';
+var POINTS = 4, ATTRIBUTES = 7, STRIDE = POINTS * ATTRIBUTES;
+var EdgeClampedProgram = /** @class */ (function (_super) {
+    __extends(EdgeClampedProgram, _super);
+    function EdgeClampedProgram(gl) {
+        var _this = _super.call(this, gl, vertexShaderSource, fragmentShaderSource, POINTS, ATTRIBUTES) || this;
+        // Initializing indices buffer
+        var indicesBuffer = gl.createBuffer();
+        if (indicesBuffer === null)
+            throw new Error('EdgeClampedProgram: error while getting resolutionLocation');
+        _this.indicesBuffer = indicesBuffer;
+        // Locations:
+        _this.positionLocation = gl.getAttribLocation(_this.program, 'a_position');
+        _this.colorLocation = gl.getAttribLocation(_this.program, 'a_color');
+        _this.normalLocation = gl.getAttribLocation(_this.program, 'a_normal');
+        _this.radiusLocation = gl.getAttribLocation(_this.program, 'a_radius');
+        _this.arrowSizeRatioLocation = gl.getAttribLocation(_this.program, 'a_arrowSizeRatio'); // our change
+        // Uniform locations
+        var matrixLocation = gl.getUniformLocation(_this.program, 'u_matrix');
+        if (matrixLocation === null)
+            throw new Error('EdgeClampedProgram: error while getting matrixLocation');
+        _this.matrixLocation = matrixLocation;
+        var sqrtZoomRatioLocation = gl.getUniformLocation(_this.program, 'u_sqrtZoomRatio');
+        if (sqrtZoomRatioLocation === null)
+            throw new Error('EdgeClampedProgram: error while getting cameraRatioLocation');
+        _this.sqrtZoomRatioLocation = sqrtZoomRatioLocation;
+        var correctionRatioLocation = gl.getUniformLocation(_this.program, 'u_correctionRatio');
+        if (correctionRatioLocation === null)
+            throw new Error('EdgeClampedProgram: error while getting viewportRatioLocation');
+        _this.correctionRatioLocation = correctionRatioLocation;
+        // Enabling the OES_element_index_uint extension
+        // NOTE: on older GPUs, this means that really large graphs won't
+        // have all their edges rendered. But it seems that the
+        // `OES_element_index_uint` is quite everywhere so we'll handle
+        // the potential issue if it really arises.
+        // NOTE: when using webgl2, the extension is enabled by default
+        _this.canUse32BitsIndices = canUse32BitsIndices(gl);
+        _this.IndicesArray = _this.canUse32BitsIndices ? Uint32Array : Uint16Array;
+        _this.indicesArray = new _this.IndicesArray();
+        _this.indicesType = _this.canUse32BitsIndices ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+        _this.bind();
+        return _this;
+    }
+    EdgeClampedProgram.prototype.bind = function () {
+        var gl = this.gl;
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indicesBuffer);
+        // Bindings
+        gl.enableVertexAttribArray(this.positionLocation);
+        gl.enableVertexAttribArray(this.normalLocation);
+        gl.enableVertexAttribArray(this.colorLocation);
+        gl.enableVertexAttribArray(this.radiusLocation);
+        gl.enableVertexAttribArray(this.arrowSizeRatioLocation); // our change
+        gl.vertexAttribPointer(this.positionLocation, 2, gl.FLOAT, false, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 0);
+        gl.vertexAttribPointer(this.normalLocation, 2, gl.FLOAT, false, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 8);
+        gl.vertexAttribPointer(this.colorLocation, 4, gl.UNSIGNED_BYTE, true, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 16);
+        gl.vertexAttribPointer(this.radiusLocation, 1, gl.FLOAT, false, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 20);
+        // our change
+        gl.vertexAttribPointer(this.arrowSizeRatioLocation, 1, gl.FLOAT, false, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 24);
+    };
+    EdgeClampedProgram.prototype.process = function (sourceData, targetData, data, hidden, offset) {
+        if (hidden) {
+            for (var i_1 = offset * STRIDE, l = i_1 + STRIDE; i_1 < l; i_1++)
+                this.array[i_1] = 0;
+            return;
+        }
+        var arrowSizeRatio = data.arrowSizeRatio || 1; // our change
+        var thickness = data.size || 1, x1 = sourceData.x, y1 = sourceData.y, x2 = targetData.x, y2 = targetData.y, 
+        //our change - added sourceRadius
+        sourceRadius = data.type === 'doubleArrow' ? sourceData.size || 1 : 0, targetRadius = targetData.size || 1, color = floatColor(data.color);
+        // Computing normals
+        var dx = x2 - x1, dy = y2 - y1;
+        var len = dx * dx + dy * dy, n1 = 0, n2 = 0;
+        if (len) {
+            len = 1 / Math.sqrt(len);
+            n1 = -dy * len * thickness;
+            n2 = dx * len * thickness;
+        }
+        var i = POINTS * ATTRIBUTES * offset;
+        var array = this.array;
+        // First point
+        array[i++] = x1;
+        array[i++] = y1;
+        array[i++] = n1;
+        array[i++] = n2;
+        array[i++] = color;
+        array[i++] = -sourceRadius;
+        array[i++] = arrowSizeRatio;
+        // First point flipped
+        array[i++] = x1;
+        array[i++] = y1;
+        array[i++] = -n1;
+        array[i++] = -n2;
+        array[i++] = color;
+        array[i++] = sourceRadius;
+        array[i++] = arrowSizeRatio;
+        // Second point
+        array[i++] = x2;
+        array[i++] = y2;
+        array[i++] = n1;
+        array[i++] = n2;
+        array[i++] = color;
+        array[i++] = targetRadius;
+        array[i++] = arrowSizeRatio;
+        // Second point flipped
+        array[i++] = x2;
+        array[i++] = y2;
+        array[i++] = -n1;
+        array[i++] = -n2;
+        array[i++] = color;
+        array[i++] = -targetRadius;
+        array[i] = arrowSizeRatio;
+    };
+    EdgeClampedProgram.prototype.computeIndices = function () {
+        var l = this.array.length / ATTRIBUTES;
+        var size = l + l / 2;
+        var indices = new this.IndicesArray(size);
+        for (var i = 0, c = 0; i < l; i += 4) {
+            indices[c++] = i;
+            indices[c++] = i + 1;
+            indices[c++] = i + 2;
+            indices[c++] = i + 2;
+            indices[c++] = i + 1;
+            indices[c++] = i + 3;
+        }
+        this.indicesArray = indices;
+    };
+    EdgeClampedProgram.prototype.bufferData = function () {
+        _super.prototype.bufferData.call(this);
+        // Indices data
+        var gl = this.gl;
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.indicesArray, gl.STATIC_DRAW);
+    };
+    EdgeClampedProgram.prototype.render = function (params) {
+        if (this.hasNothingToRender())
+            return;
+        var gl = this.gl;
+        var program = this.program;
+        gl.useProgram(program);
+        // Binding uniforms
+        gl.uniformMatrix3fv(this.matrixLocation, false, params.matrix);
+        gl.uniform1f(this.sqrtZoomRatioLocation, Math.sqrt(params.ratio));
+        gl.uniform1f(this.correctionRatioLocation, params.correctionRatio);
+        // Drawing:
+        gl.drawElements(gl.TRIANGLES, this.indicesArray.length, this.indicesType, 0);
+    };
+    return EdgeClampedProgram;
+}(AbstractEdgeProgram));
+export default EdgeClampedProgram;

package/esm/features/graph/rendering/webgl/edge.dashed.d.ts

@@ -0,0 +1,23 @@
+import { AbstractEdgeProgram } from 'sigma/rendering/webgl/programs/common/edge';
+import { RenderParams } from 'sigma/rendering/webgl/programs/common/program';
+import { EdgeDisplayData, NodeDisplayData } from 'sigma/types';
+export default class DashedEdgeProgram extends AbstractEdgeProgram {
+    IndicesArray: Uint32ArrayConstructor | Uint16ArrayConstructor;
+    indicesArray: Uint32Array | Uint16Array;
+    indicesBuffer: WebGLBuffer;
+    indicesType: GLenum;
+    canUse32BitsIndices: boolean;
+    positionLocation: GLint;
+    colorLocation: GLint;
+    normalLocation: GLint;
+    lineLengthLocation: GLint;
+    matrixLocation: WebGLUniformLocation;
+    sqrtZoomRatioLocation: WebGLUniformLocation;
+    correctionRatioLocation: WebGLUniformLocation;
+    constructor(gl: WebGLRenderingContext);
+    bind(): void;
+    computeIndices(): void;
+    bufferData(): void;
+    process(sourceData: NodeDisplayData, targetData: NodeDisplayData, data: EdgeDisplayData, hidden: boolean, offset: number): void;
+    render(params: RenderParams): void;
+}

package/esm/features/graph/rendering/webgl/edge.dashed.js

@@ -0,0 +1,160 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/**
+ * This is a copy of sigma/src/rendering/webgl/programs/edge.ts
+ * with changes to add dashed edge support
+ */
+import { floatColor, canUse32BitsIndices } from 'sigma/utils';
+import { AbstractEdgeProgram } from 'sigma/rendering/webgl/programs/common/edge';
+import { fragmentShaderSource } from './shaders/edge.dashed.frag.glsl';
+import { vertexShaderSource } from './shaders/edge.dashed.vert.glsl';
+var POINTS = 4, ATTRIBUTES = 6, // our change 5 -> 6
+STRIDE = POINTS * ATTRIBUTES;
+var DashedEdgeProgram = /** @class */ (function (_super) {
+    __extends(DashedEdgeProgram, _super);
+    function DashedEdgeProgram(gl) {
+        var _this = _super.call(this, gl, vertexShaderSource, fragmentShaderSource, POINTS, ATTRIBUTES) || this;
+        // Initializing indices buffer
+        var indicesBuffer = gl.createBuffer();
+        if (indicesBuffer === null)
+            throw new Error('EdgeProgram: error while creating indicesBuffer');
+        _this.indicesBuffer = indicesBuffer;
+        // Locations
+        _this.positionLocation = gl.getAttribLocation(_this.program, 'a_position');
+        _this.colorLocation = gl.getAttribLocation(_this.program, 'a_color');
+        _this.normalLocation = gl.getAttribLocation(_this.program, 'a_normal');
+        _this.lineLengthLocation = gl.getAttribLocation(_this.program, 'a_lineLength'); // our addition
+        var matrixLocation = gl.getUniformLocation(_this.program, 'u_matrix');
+        if (matrixLocation === null)
+            throw new Error('EdgeProgram: error while getting matrixLocation');
+        _this.matrixLocation = matrixLocation;
+        var correctionRatioLocation = gl.getUniformLocation(_this.program, 'u_correctionRatio');
+        if (correctionRatioLocation === null)
+            throw new Error('EdgeProgram: error while getting correctionRatioLocation');
+        _this.correctionRatioLocation = correctionRatioLocation;
+        var sqrtZoomRatioLocation = gl.getUniformLocation(_this.program, 'u_sqrtZoomRatio');
+        if (sqrtZoomRatioLocation === null)
+            throw new Error('EdgeProgram: error while getting sqrtZoomRatioLocation');
+        _this.sqrtZoomRatioLocation = sqrtZoomRatioLocation;
+        // Enabling the OES_element_index_uint extension
+        // NOTE: on older GPUs, this means that really large graphs won't
+        // have all their edges rendered. But it seems that the
+        // `OES_element_index_uint` is quite everywhere so we'll handle
+        // the potential issue if it really arises.
+        // NOTE: when using webgl2, the extension is enabled by default
+        _this.canUse32BitsIndices = canUse32BitsIndices(gl);
+        _this.IndicesArray = _this.canUse32BitsIndices ? Uint32Array : Uint16Array;
+        _this.indicesArray = new _this.IndicesArray();
+        _this.indicesType = _this.canUse32BitsIndices ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+        _this.bind();
+        return _this;
+    }
+    DashedEdgeProgram.prototype.bind = function () {
+        var gl = this.gl;
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indicesBuffer);
+        // Bindings
+        gl.enableVertexAttribArray(this.positionLocation);
+        gl.enableVertexAttribArray(this.normalLocation);
+        gl.enableVertexAttribArray(this.lineLengthLocation); // our addition
+        gl.enableVertexAttribArray(this.colorLocation);
+        gl.vertexAttribPointer(this.positionLocation, 2, gl.FLOAT, false, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 0);
+        gl.vertexAttribPointer(this.normalLocation, 2, gl.FLOAT, false, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 8);
+        gl.vertexAttribPointer(this.lineLengthLocation, 1, gl.FLOAT, false, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 16); // our addition
+        gl.vertexAttribPointer(this.colorLocation, 4, gl.UNSIGNED_BYTE, true, ATTRIBUTES * Float32Array.BYTES_PER_ELEMENT, 20 // changed from 16 to 20
+        );
+    };
+    DashedEdgeProgram.prototype.computeIndices = function () {
+        var l = this.array.length / ATTRIBUTES;
+        var size = l + l / 2;
+        var indices = new this.IndicesArray(size);
+        for (var i = 0, c = 0; i < l; i += 4) {
+            indices[c++] = i;
+            indices[c++] = i + 1;
+            indices[c++] = i + 2;
+            indices[c++] = i + 2;
+            indices[c++] = i + 1;
+            indices[c++] = i + 3;
+        }
+        this.indicesArray = indices;
+    };
+    DashedEdgeProgram.prototype.bufferData = function () {
+        _super.prototype.bufferData.call(this);
+        // Indices data
+        var gl = this.gl;
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.indicesArray, gl.STATIC_DRAW);
+    };
+    DashedEdgeProgram.prototype.process = function (sourceData, targetData, data, hidden, offset) {
+        if (hidden) {
+            for (var i_1 = offset * STRIDE, l = i_1 + STRIDE; i_1 < l; i_1++)
+                this.array[i_1] = 0;
+            return;
+        }
+        var thickness = data.size || 1, x1 = sourceData.x, y1 = sourceData.y, x2 = targetData.x, y2 = targetData.y, color = floatColor(data.color);
+        // Computing normals
+        var dx = x2 - x1, dy = y2 - y1;
+        var len = dx * dx + dy * dy, n1 = 0, n2 = 0;
+        var lineLength = Math.sqrt(len); // our addition
+        if (len) {
+            len = 1 / Math.sqrt(len);
+            n1 = -dy * len * thickness;
+            n2 = dx * len * thickness;
+        }
+        var i = POINTS * ATTRIBUTES * offset;
+        var array = this.array;
+        // First point
+        array[i++] = x1;
+        array[i++] = y1;
+        array[i++] = n1;
+        array[i++] = n2;
+        array[i++] = 0; // our addition
+        array[i++] = color;
+        // First point flipped
+        array[i++] = x1;
+        array[i++] = y1;
+        array[i++] = -n1;
+        array[i++] = -n2;
+        array[i++] = 0; // our addition
+        array[i++] = color;
+        // Second point
+        array[i++] = x2;
+        array[i++] = y2;
+        array[i++] = n1;
+        array[i++] = n2;
+        array[i++] = lineLength; // our addition
+        array[i++] = color;
+        // Second point flipped
+        array[i++] = x2;
+        array[i++] = y2;
+        array[i++] = -n1;
+        array[i++] = -n2;
+        array[i++] = lineLength; // our addition
+        array[i] = color;
+    };
+    DashedEdgeProgram.prototype.render = function (params) {
+        if (this.hasNothingToRender())
+            return;
+        var gl = this.gl;
+        var program = this.program;
+        gl.useProgram(program);
+        gl.uniformMatrix3fv(this.matrixLocation, false, params.matrix);
+        gl.uniform1f(this.sqrtZoomRatioLocation, Math.sqrt(params.ratio));
+        gl.uniform1f(this.correctionRatioLocation, params.correctionRatio);
+        // Drawing:
+        gl.drawElements(gl.TRIANGLES, this.indicesArray.length, this.indicesType, 0);
+    };
+    return DashedEdgeProgram;
+}(AbstractEdgeProgram));
+export default DashedEdgeProgram;

package/esm/features/graph/rendering/webgl/edge.reversedArrowHead.d.ts

@@ -0,0 +1,5 @@
+import { GraphEdgeAttributes, GraphNodeAttributes } from '../../types/graphDataTypes';
+import EdgeArrowHeadProgram from './edge.arrowHead';
+export default class EdgeReversedArrowHeadProgram extends EdgeArrowHeadProgram {
+    process(sourceData: GraphNodeAttributes, targetData: GraphNodeAttributes, data: GraphEdgeAttributes, hidden: boolean, offset: number): void;
+}

package/esm/features/graph/rendering/webgl/edge.reversedArrowHead.js

@@ -0,0 +1,27 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import EdgeArrowHeadProgram from './edge.arrowHead';
+var EdgeReversedArrowHeadProgram = /** @class */ (function (_super) {
+    __extends(EdgeReversedArrowHeadProgram, _super);
+    function EdgeReversedArrowHeadProgram() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EdgeReversedArrowHeadProgram.prototype.process = function (sourceData, targetData, data, hidden, offset) {
+        _super.prototype.process.call(this, targetData, sourceData, data, hidden, offset);
+    };
+    return EdgeReversedArrowHeadProgram;
+}(EdgeArrowHeadProgram));
+export default EdgeReversedArrowHeadProgram;

package/esm/features/graph/rendering/webgl/helpers/imageHelper.d.ts

@@ -0,0 +1,17 @@
+import { Coordinates, Dimensions } from 'sigma/types';
+type ImageLoading = {
+    status: 'loading';
+};
+type ImageError = {
+    status: 'error';
+};
+type ImagePending = {
+    status: 'pending';
+    image: HTMLImageElement;
+};
+type ImageReady = {
+    status: 'ready';
+} & Coordinates & Dimensions;
+export type ImageType = ImageLoading | ImageError | ImagePending | ImageReady;
+export declare const clearCrossOriginForCORSIfNotSameOrigin: (img: HTMLImageElement, url: string) => void;
+export {};

package/esm/features/graph/rendering/webgl/helpers/imageHelper.js

@@ -0,0 +1,5 @@
+export var clearCrossOriginForCORSIfNotSameOrigin = function (img, url) {
+    if (new URL(url, window.location.href).origin !== window.location.origin) {
+        img.crossOrigin = '';
+    }
+};

package/esm/features/graph/rendering/webgl/helpers/imageHelper.spec.d.ts

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

package/esm/features/graph/rendering/webgl/helpers/imageHelper.spec.js

@@ -0,0 +1,27 @@
+import { clearCrossOriginForCORSIfNotSameOrigin } from './imageHelper';
+describe('clearCrossOriginForCORSIfNotSameOrigin tests', function () {
+    var savedLocation = window.location;
+    beforeEach(function () {
+        delete window.location;
+        window.location = {
+            origin: 'http://test'
+        };
+    });
+    afterEach(function () {
+        window.location = savedLocation;
+    });
+    it('should clear crossOrigin if origin is not the same', function () {
+        var img = new Image();
+        var url = 'http://imagePath/images/123.png';
+        img.crossOrigin = 'testValue';
+        clearCrossOriginForCORSIfNotSameOrigin(img, url);
+        expect(img.crossOrigin).toBe('');
+    });
+    it('should not clear crossOrigin if origin is the same', function () {
+        var img = new Image();
+        var url = 'http://test/images/123.png';
+        img.crossOrigin = 'testValue';
+        clearCrossOriginForCORSIfNotSameOrigin(img, url);
+        expect(img.crossOrigin).toBe('testValue');
+    });
+});

package/esm/features/graph/rendering/webgl/image.d.ts

@@ -0,0 +1,17 @@
+import { ImageType } from './helpers/imageHelper';
+export declare class WebGLImageLoader {
+    rebindTextureFns: (() => void)[];
+    images: Record<string, ImageType>;
+    textureImage: ImageData;
+    hasReceivedImages: boolean;
+    pendingImagesFrameID: number | undefined;
+    constructor();
+    /**
+     * Helper to load an image:
+     */
+    loadImage: (id: string, imageSource: string) => void;
+    /**
+     * Helper that takes all pending images and adds them into the texture:
+     */
+    finalizePendingImages: () => void;
+}