@react-fabric/graph 1.0.0-beta.63 → 1.0.2

package/dist/esm/programs/arrow-head/index.js

@@ -1,141 +0,0 @@
-'use client';
-
-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 _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { EdgeProgram } 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; })(); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var _WebGLRenderingContex = WebGLRenderingContext,
-  UNSIGNED_BYTE = _WebGLRenderingContex.UNSIGNED_BYTE,
-  FLOAT = _WebGLRenderingContex.FLOAT;
-var UNIFORMS = ["u_matrix", "u_sizeRatio", "u_correctionRatio", "u_minEdgeThickness", "u_lengthToThicknessRatio", "u_widenessToThicknessRatio"];
-var DEFAULT_EDGE_ARROW_HEAD_PROGRAM_OPTIONS = {
-  extremity: "target",
-  lengthToThicknessRatio: 2.5,
-  widenessToThicknessRatio: 2
-};
-function createEdgeArrowHeadProgram(inputOptions) {
-  var options = _objectSpread(_objectSpread({}, DEFAULT_EDGE_ARROW_HEAD_PROGRAM_OPTIONS), inputOptions !== null && inputOptions !== void 0 ? inputOptions : {});
-  return /*#__PURE__*/function (_EdgeProgram) {
-    function EdgeArrowHeadProgram() {
-      _classCallCheck(this, EdgeArrowHeadProgram);
-      return _callSuper(this, EdgeArrowHeadProgram, arguments);
-    }
-    _inherits(EdgeArrowHeadProgram, _EdgeProgram);
-    return _createClass(EdgeArrowHeadProgram, [{
-      key: "getDefinition",
-      value: function getDefinition() {
-        return {
-          VERTICES: 3,
-          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_normal",
-            size: 2,
-            type: FLOAT
-          }, {
-            name: "a_radius",
-            size: 1,
-            type: FLOAT
-          }, {
-            name: "a_color",
-            size: 4,
-            type: UNSIGNED_BYTE,
-            normalized: true
-          }, {
-            name: "a_opacity",
-            size: 1,
-            type: FLOAT
-          }, {
-            name: "a_id",
-            size: 4,
-            type: UNSIGNED_BYTE,
-            normalized: true
-          }],
-          CONSTANT_ATTRIBUTES: [{
-            name: "a_barycentric",
-            size: 3,
-            type: FLOAT
-          }],
-          CONSTANT_DATA: [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
-        };
-      }
-    }, {
-      key: "processVisibleItem",
-      value: function processVisibleItem(edgeIndex, startIndex, sourceData, targetData, data) {
-        var _data$arrow, _data$opacity;
-        if (options.extremity === "source") {
-          var _ref = [targetData, sourceData];
-          sourceData = _ref[0];
-          targetData = _ref[1];
-        }
-        var thickness = Math.min(data.size || 1, 0.5) * 8;
-        var radius = targetData.size || 1;
-        var x1 = sourceData.x;
-        var y1 = sourceData.y;
-        var x2 = targetData.x;
-        var y2 = targetData.y;
-        var color = data.color;
-        if (data.selected) color = "#f00";
-        if (data.highlight) color = "#F54A4A";
-
-        // Computing normals
-        var dx = x2 - x1;
-        var dy = y2 - y1;
-        var len = dx * dx + dy * dy;
-        var n1 = 0;
-        var n2 = 0;
-        if (len) {
-          len = 1 / Math.sqrt(len);
-          n1 = -dy * len * thickness;
-          n2 = dx * len * thickness;
-        }
-        var array = this.array;
-        array[startIndex++] = x2;
-        array[startIndex++] = y2;
-        array[startIndex++] = -n1;
-        array[startIndex++] = -n2;
-        array[startIndex++] = radius;
-        array[startIndex++] = floatColor(color);
-        array[startIndex++] = ["both", options.extremity].includes((_data$arrow = data.arrow) !== null && _data$arrow !== void 0 ? _data$arrow : "") ? (_data$opacity = data.opacity) !== null && _data$opacity !== void 0 ? _data$opacity : 1 : 0;
-        array[startIndex++] = edgeIndex;
-      }
-    }, {
-      key: "setUniforms",
-      value: function setUniforms(params, _ref2) {
-        var gl = _ref2.gl,
-          uniformLocations = _ref2.uniformLocations;
-        var u_matrix = uniformLocations.u_matrix,
-          u_sizeRatio = uniformLocations.u_sizeRatio,
-          u_correctionRatio = uniformLocations.u_correctionRatio,
-          u_minEdgeThickness = uniformLocations.u_minEdgeThickness,
-          u_lengthToThicknessRatio = uniformLocations.u_lengthToThicknessRatio,
-          u_widenessToThicknessRatio = uniformLocations.u_widenessToThicknessRatio;
-        gl.uniformMatrix3fv(u_matrix, false, params.matrix);
-        gl.uniform1f(u_sizeRatio, params.sizeRatio);
-        gl.uniform1f(u_correctionRatio, params.correctionRatio);
-        gl.uniform1f(u_minEdgeThickness, params.minEdgeThickness);
-        gl.uniform1f(u_lengthToThicknessRatio, 2.5);
-        gl.uniform1f(u_widenessToThicknessRatio, 2);
-      }
-    }]);
-  }(EdgeProgram);
-}
-
-export { DEFAULT_EDGE_ARROW_HEAD_PROGRAM_OPTIONS, createEdgeArrowHeadProgram };

package/dist/esm/programs/arrow-head/vert.glsl.js

@@ -1,8 +0,0 @@
-'use client';
-
-/* istanbul ignore file */
-
-// language=GLSL
-var SHADER_SOURCE = /* glsl */"\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 { SHADER_SOURCE as default };

package/dist/esm/programs/edge-curve/drawLabel.js

@@ -1,136 +0,0 @@
-'use client';
-
-/* istanbul ignore file */
-
-function getCurvePoint(t, p0, p1, p2) {
-  var x = Math.pow(1 - t, 2) * p0.x + 2 * (1 - t) * t * p1.x + Math.pow(t, 2) * p2.x;
-  var y = Math.pow(1 - t, 2) * p0.y + 2 * (1 - t) * t * p1.y + Math.pow(t, 2) * p2.y;
-  return {
-    x: x,
-    y: y
-  };
-}
-function getCurveLength(p0, p1, p2) {
-  var steps = 20;
-  var length = 0;
-  var lastPoint = p0;
-  for (var i = 0; i < steps; i++) {
-    var point = getCurvePoint((i + 1) / steps, p0, p1, p2);
-    length += Math.sqrt(Math.pow(lastPoint.x - point.x, 2) + Math.pow(lastPoint.y - point.y, 2));
-    lastPoint = point;
-  }
-  return length;
-}
-function createDrawCurvedEdgeLabel(_ref) {
-  var curvatureAttribute = _ref.curvatureAttribute,
-    defaultCurvature = _ref.defaultCurvature,
-    _ref$keepLabelUpright = _ref.keepLabelUpright,
-    keepLabelUpright = _ref$keepLabelUpright === void 0 ? true : _ref$keepLabelUpright;
-  return function (context, edgeData, sourceData, targetData, settings) {
-    var _edgeData$color;
-    var size = settings.edgeLabelSize;
-    var curvature = edgeData[curvatureAttribute] || defaultCurvature;
-    var font = settings.edgeLabelFont;
-    var weight = settings.edgeLabelWeight;
-    var color = (_edgeData$color = edgeData.color) !== null && _edgeData$color !== void 0 ? _edgeData$color : settings.defaultEdgeColor;
-    if (edgeData.selected) color = "#f00";
-    if (edgeData.highlight) color = "#F54A4A";
-    var label = edgeData.label;
-    if (!label || edgeData.opacity < 1) return;
-    context.font = "".concat(weight, " ").concat(size, "px ").concat(font);
-
-    // Computing positions without considering nodes sizes:
-    var ltr = !keepLabelUpright || sourceData.x < targetData.x;
-    var sourceX = ltr ? sourceData.x : targetData.x;
-    var sourceY = ltr ? sourceData.y : targetData.y;
-    var targetX = ltr ? targetData.x : sourceData.x;
-    var targetY = ltr ? targetData.y : sourceData.y;
-    var centerX = (sourceX + targetX) / 2;
-    var centerY = (sourceY + targetY) / 2;
-    var diffX = targetX - sourceX;
-    var diffY = targetY - sourceY;
-    var diff = Math.sqrt(Math.pow(diffX, 2) + Math.pow(diffY, 2));
-    // Anchor point:
-    var orientation = ltr ? 1 : -1;
-    var anchorX = centerX + diffY * curvature * orientation;
-    var anchorY = centerY - diffX * curvature * orientation;
-
-    // Adapt curve points to edge thickness:
-    var offset = edgeData.size * 0.7 + 5;
-    var sourceOffsetVector = {
-      x: anchorY - sourceY,
-      y: -(anchorX - sourceX)
-    };
-    var sourceOffsetVectorLength = Math.sqrt(Math.pow(sourceOffsetVector.x, 2) + Math.pow(sourceOffsetVector.y, 2));
-    var targetOffsetVector = {
-      x: targetY - anchorY,
-      y: -(targetX - anchorX)
-    };
-    var targetOffsetVectorLength = Math.sqrt(Math.pow(targetOffsetVector.x, 2) + Math.pow(targetOffsetVector.y, 2));
-    sourceX += offset * sourceOffsetVector.x / sourceOffsetVectorLength;
-    sourceY += offset * sourceOffsetVector.y / sourceOffsetVectorLength;
-    targetX += offset * targetOffsetVector.x / targetOffsetVectorLength;
-    targetY += offset * targetOffsetVector.y / targetOffsetVectorLength;
-    // For anchor, the vector is simpler, so it is inlined:
-    anchorX += offset * diffY / diff;
-    anchorY -= offset * diffX / diff;
-
-    // Compute curve length:
-    var anchorPoint = {
-      x: anchorX,
-      y: anchorY
-    };
-    var sourcePoint = {
-      x: sourceX,
-      y: sourceY
-    };
-    var targetPoint = {
-      x: targetX,
-      y: targetY
-    };
-    var curveLength = getCurveLength(sourcePoint, anchorPoint, targetPoint);
-    if (curveLength < sourceData.size + targetData.size) return;
-
-    // Handling ellipsis
-    var textLength = context.measureText(label).width;
-    var availableTextLength = curveLength - sourceData.size - targetData.size;
-    if (textLength > availableTextLength) {
-      var ellipsis = "…";
-      label = label + ellipsis;
-      textLength = context.measureText(label).width;
-      while (textLength > availableTextLength && label.length > 1) {
-        label = label.slice(0, -2) + ellipsis;
-        textLength = context.measureText(label).width;
-      }
-      if (label.length < 4) return;
-    }
-
-    // Measure each character:
-    var charactersLengthCache = {};
-    for (var i = 0, length = label.length; i < length; i++) {
-      var character = label[i];
-      if (!charactersLengthCache[character]) {
-        charactersLengthCache[character] = context.measureText(character).width * (1 + curvature * 0.35);
-      }
-    }
-
-    // Draw each character:
-    var t = 0.5 - textLength / curveLength / 2;
-    for (var _i = 0, _length = label.length; _i < _length; _i++) {
-      var _character = label[_i];
-      var point = getCurvePoint(t, sourcePoint, anchorPoint, targetPoint);
-      var tangentX = 2 * (1 - t) * (anchorX - sourceX) + 2 * t * (targetX - anchorX);
-      var tangentY = 2 * (1 - t) * (anchorY - sourceY) + 2 * t * (targetY - anchorY);
-      var angle = Math.atan2(tangentY, tangentX);
-      context.save();
-      context.translate(point.x, point.y);
-      context.rotate(angle);
-      context.fillStyle = color;
-      context.fillText(_character, 0, 0);
-      context.restore();
-      t += charactersLengthCache[_character] / curveLength;
-    }
-  };
-}
-
-export { createDrawCurvedEdgeLabel };

package/dist/esm/programs/edge-curve/frag.glsl.js

@@ -1,8 +0,0 @@
-'use client';
-
-/* istanbul ignore file */
-
-// language=GLSL
-var SHADER = /* glsl */"\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 { SHADER as default };

package/dist/esm/programs/edge-curve/index.js

@@ -1,156 +0,0 @@
-'use client';
-
-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 { DEFAULT_EDGE_CURVATURE } from '@sigma/edge-curve';
-import { createEdgeCompoundProgram, EdgeProgram } from 'sigma/rendering';
-import { floatColor } from 'sigma/utils';
-import { createDrawCurvedEdgeLabel } from './drawLabel.js';
-import SHADER$1 from './frag.glsl.js';
-import SHADER 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_matrix", "u_sizeRatio", "u_dimensions", "u_pixelRatio", "u_feather", "u_minEdgeThickness", "u_lengthToThicknessRatio", "u_widenessToThicknessRatio"];
-var EdgeCurveProgramBase = /*#__PURE__*/function (_EdgeProgram) {
-  function EdgeCurveProgramBase() {
-    _classCallCheck(this, EdgeCurveProgramBase);
-    return _callSuper(this, EdgeCurveProgramBase, arguments);
-  }
-  _inherits(EdgeCurveProgramBase, _EdgeProgram);
-  return _createClass(EdgeCurveProgramBase, [{
-    key: "getDefinition",
-    value: function getDefinition() {
-      return {
-        VERTICES: 6,
-        VERTEX_SHADER_SOURCE: SHADER,
-        FRAGMENT_SHADER_SOURCE: SHADER$1,
-        METHOD: WebGLRenderingContext.TRIANGLES,
-        UNIFORMS: UNIFORMS,
-        ATTRIBUTES: [{
-          name: "a_source",
-          size: 2,
-          type: FLOAT
-        }, {
-          name: "a_target",
-          size: 2,
-          type: FLOAT
-        }, {
-          name: "a_thickness",
-          size: 1,
-          type: FLOAT
-        }, {
-          name: "a_curvature",
-          size: 1,
-          type: FLOAT
-        }, {
-          name: "a_color",
-          size: 4,
-          type: UNSIGNED_BYTE,
-          normalized: true
-        }, {
-          name: "a_opacity",
-          size: 1,
-          type: FLOAT
-        }, {
-          name: "a_id",
-          size: 4,
-          type: UNSIGNED_BYTE,
-          normalized: true
-        }, {
-          name: "a_sourceSize",
-          size: 1,
-          type: FLOAT
-        }, {
-          name: "a_targetSize",
-          size: 1,
-          type: FLOAT
-        }],
-        CONSTANT_ATTRIBUTES: [{
-          name: "a_current",
-          size: 1,
-          type: FLOAT
-        },
-        // TODO: could optimize to bool
-        {
-          name: "a_direction",
-          size: 1,
-          type: FLOAT
-        } // TODO: could optimize to byte
-        ],
-        CONSTANT_DATA: [[0, 1], [0, -1], [1, 1], [0, -1], [1, 1], [1, -1]]
-      };
-    }
-  }, {
-    key: "processVisibleItem",
-    value: function processVisibleItem(edgeIndex, startIndex, sourceData, targetData, data) {
-      var _data$color, _data$selected, _data$curvature, _data$opacity, _data$arrow, _data$arrow2;
-      var color = (_data$color = data.color) !== null && _data$color !== void 0 ? _data$color : this.renderer.getSetting("defaultEdgeColor");
-      if (data.selected) color = "#f00";
-      if (data.highlight) color = "#F54A4A";
-      var thickness = Math.min(data.size || 1, 0.5) * (((_data$selected = data.selected) !== null && _data$selected !== void 0 ? _data$selected : data.highlight) ? 16 : 8);
-      var x1 = sourceData.x;
-      var y1 = sourceData.y;
-      var x2 = targetData.x;
-      var y2 = targetData.y;
-      var curvature = (_data$curvature = data.curvature) !== null && _data$curvature !== void 0 ? _data$curvature : DEFAULT_EDGE_CURVATURE;
-      var sourceRadius = sourceData.size || 1;
-      var targetRadius = targetData.size || 1;
-      var array = this.array;
-
-      // First point
-      array[startIndex++] = x1;
-      array[startIndex++] = y1;
-      array[startIndex++] = x2;
-      array[startIndex++] = y2;
-      array[startIndex++] = thickness;
-      array[startIndex++] = curvature;
-      array[startIndex++] = floatColor(color);
-      array[startIndex++] = (_data$opacity = data.opacity) !== null && _data$opacity !== void 0 ? _data$opacity : 1;
-      array[startIndex++] = edgeIndex;
-      array[startIndex++] = ["both", "source"].includes((_data$arrow = data.arrow) !== null && _data$arrow !== void 0 ? _data$arrow : "") ? sourceRadius : 0;
-      array[startIndex++] = ["both", "target"].includes((_data$arrow2 = data.arrow) !== null && _data$arrow2 !== void 0 ? _data$arrow2 : "") ? targetRadius : 0;
-    }
-  }, {
-    key: "setUniforms",
-    value: function setUniforms(params, _ref) {
-      var gl = _ref.gl,
-        uniformLocations = _ref.uniformLocations;
-      var u_matrix = uniformLocations.u_matrix,
-        u_pixelRatio = uniformLocations.u_pixelRatio,
-        u_feather = uniformLocations.u_feather,
-        u_sizeRatio = uniformLocations.u_sizeRatio,
-        u_dimensions = uniformLocations.u_dimensions,
-        u_minEdgeThickness = uniformLocations.u_minEdgeThickness,
-        u_lengthToThicknessRatio = uniformLocations.u_lengthToThicknessRatio,
-        u_widenessToThicknessRatio = uniformLocations.u_widenessToThicknessRatio;
-      gl.uniformMatrix3fv(u_matrix, false, params.matrix);
-      gl.uniform1f(u_pixelRatio, params.pixelRatio);
-      gl.uniform1f(u_sizeRatio, params.sizeRatio);
-      gl.uniform1f(u_feather, params.antiAliasingFeather);
-      gl.uniform2f(u_dimensions, params.width * params.pixelRatio, params.height * params.pixelRatio);
-      gl.uniform1f(u_minEdgeThickness, params.minEdgeThickness);
-      gl.uniform1f(u_lengthToThicknessRatio, 2.5);
-      gl.uniform1f(u_widenessToThicknessRatio, 2);
-    }
-  }]);
-}(EdgeProgram);
-var EdgeCurveProgram = createEdgeCompoundProgram([EdgeCurveProgramBase
-// createEdgeArrowHeadProgram({ extremity: "source" }),
-// createEdgeArrowHeadProgram({ extremity: "target" }),
-], createDrawCurvedEdgeLabel({
-  curvatureAttribute: "curvature",
-  defaultCurvature: DEFAULT_EDGE_CURVATURE,
-  arrowHead: null
-}));
-
-export { EdgeCurveProgram, EdgeCurveProgramBase };

package/dist/esm/programs/edge-curve/vert.glsl.js

@@ -1,8 +0,0 @@
-'use client';
-
-/* istanbul ignore file */
-
-// language=GLSL
-var SHADER = /* glsl */"\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 { SHADER as default };

package/dist/esm/programs/edge-line/drawLabel.js

@@ -1,70 +0,0 @@
-'use client';
-
-/* istanbul ignore file */
-
-function drawLineLabel(context, edgeData, sourceData, targetData, settings) {
-  var _edgeData$color;
-  var size = settings.edgeLabelSize;
-  var font = settings.edgeLabelFont;
-  var weight = settings.edgeLabelWeight;
-  var color = (_edgeData$color = edgeData.color) !== null && _edgeData$color !== void 0 ? _edgeData$color : settings.defaultEdgeColor;
-  if (edgeData.selected) color = "#f00";
-  if (edgeData.highlight) color = "#F54A4A";
-  var label = edgeData.label;
-  if (!label || edgeData.opacity < 1) return;
-  context.font = "".concat(weight, " ").concat(size, "px ").concat(font);
-
-  // Computing positions without considering nodes sizes:
-  var sSize = sourceData.size;
-  var tSize = targetData.size;
-  var sx = sourceData.x;
-  var sy = sourceData.y;
-  var tx = targetData.x;
-  var ty = targetData.y;
-  var cx = (sx + tx) / 2;
-  var cy = (sy + ty) / 2;
-  var dx = tx - sx;
-  var dy = ty - sy;
-  var d = Math.sqrt(dx * dx + dy * dy);
-  if (d < sSize + tSize) return;
-
-  // Adding nodes sizes:
-  sx += dx * sSize / d;
-  sy += dy * sSize / d;
-  tx -= dx * tSize / d;
-  ty -= dy * tSize / d;
-  cx = (sx + tx) / 2;
-  cy = (sy + ty) / 2;
-  dx = tx - sx;
-  dy = ty - sy;
-  d = Math.sqrt(dx * dx + dy * dy);
-
-  // Handling ellipsis
-  var textLength = context.measureText(label).width;
-  if (textLength > d) {
-    var ellipsis = "…";
-    label = label + ellipsis;
-    textLength = context.measureText(label).width;
-    while (textLength > d && label.length > 1) {
-      label = label.slice(0, -2) + ellipsis;
-      textLength = context.measureText(label).width;
-    }
-    if (label.length < 4) return;
-  }
-  var angle;
-  if (dx > 0) {
-    if (dy > 0) angle = Math.acos(dx / d);else angle = Math.asin(dy / d);
-  } else {
-    if (dy > 0) angle = Math.acos(dx / d) + Math.PI;else angle = Math.asin(dx / d) + Math.PI / 2;
-  }
-  context.save();
-  context.translate(cx, cy);
-  context.rotate(angle);
-  context.fillStyle = settings.defaultNodeColor || "#fff";
-  context.fillRect(-textLength / 2 - 4, edgeData.size - size + 2, textLength + 8, size + 2);
-  context.fillStyle = color;
-  context.fillText(label, -textLength / 2, edgeData.size);
-  context.restore();
-}
-
-export { drawLineLabel };

package/dist/esm/programs/edge-line/frag.glsl.js

@@ -1,8 +0,0 @@
-'use client';
-
-/* istanbul ignore file */
-
-// language=GLSL
-var SHADER_SOURCE = /* glsl */"\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 { SHADER_SOURCE as default };