@cosmos.gl/graph 2.2.0 → 2.2.1

package/dist/index.d.ts

@@ -238,24 +238,40 @@ export declare class Graph {
      * The `top` and `bottom` coordinates should be from 0 to the height of the canvas.
      * @returns A Float32Array containing the indices of points inside a rectangular area.
      */
+    getPointsInRect(selection: [[number, number], [number, number]]): Float32Array;
+    /**
+     * Get points indices inside a rectangular area.
+     * @param selection - Array of two corner points `[[left, top], [right, bottom]]`.
+     * The `left` and `right` coordinates should be from 0 to the width of the canvas.
+     * The `top` and `bottom` coordinates should be from 0 to the height of the canvas.
+     * @returns A Float32Array containing the indices of points inside a rectangular area.
+     * @deprecated Use `getPointsInRect` instead. This method will be removed in a future version.
+     */
     getPointsInRange(selection: [[number, number], [number, number]]): Float32Array;
     /**
-     * Get points indices inside a lasso (polygon) area.
-     * @param lassoPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the lasso polygon.
+     * Get points indices inside a polygon area.
+     * @param polygonPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the polygon.
      * The coordinates should be from 0 to the width/height of the canvas.
-     * @returns A Float32Array containing the indices of points inside the lasso area.
+     * @returns A Float32Array containing the indices of points inside the polygon area.
      */
-    getPointsInLasso(lassoPath: [number, number][]): Float32Array;
+    getPointsInPolygon(polygonPath: [number, number][]): Float32Array;
     /** Select points inside a rectangular area.
      * @param selection - Array of two corner points `[[left, top], [right, bottom]]`.
      * The `left` and `right` coordinates should be from 0 to the width of the canvas.
      * The `top` and `bottom` coordinates should be from 0 to the height of the canvas. */
+    selectPointsInRect(selection: [[number, number], [number, number]] | null): void;
+    /** Select points inside a rectangular area.
+     * @param selection - Array of two corner points `[[left, top], [right, bottom]]`.
+     * The `left` and `right` coordinates should be from 0 to the width of the canvas.
+     * The `top` and `bottom` coordinates should be from 0 to the height of the canvas.
+     * @deprecated Use `selectPointsInRect` instead. This method will be removed in a future version.
+     */
     selectPointsInRange(selection: [[number, number], [number, number]] | null): void;
-    /** Select points inside a lasso (polygon) area.
-     * @param lassoPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the lasso polygon.
+    /** Select points inside a polygon area.
+     * @param polygonPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the polygon.
      * The coordinates should be from 0 to the width/height of the canvas.
      * Set to null to clear selection. */
-    selectPointsInLasso(lassoPath: [number, number][] | null): void;
+    selectPointsInPolygon(polygonPath: [number, number][] | null): void;
     /**
      * Select a point by index. If you want the adjacent points to get selected too, provide `true` as the second argument.
      * @param index The index of the point in the array of points.

package/dist/index.js

@@ -10468,15 +10468,15 @@ precision highp float;
 #endif
 
 uniform sampler2D positionsTexture;
-uniform sampler2D lassoPathTexture; 
-uniform int lassoPathLength;
+uniform sampler2D polygonPathTexture; 
+uniform int polygonPathLength;
 uniform float spaceSize;
 uniform vec2 screenSize;
 uniform mat3 transformationMatrix;
 
 varying vec2 textureCoords;
 
-vec2 getLassoPoint(sampler2D pathTexture, int index, int pathLength) {
+vec2 getPolygonPoint(sampler2D pathTexture, int index, int pathLength) {
   if (index >= pathLength) return vec2(0.0);
   
   
@@ -10498,8 +10498,8 @@ bool pointInPolygon(vec2 point, sampler2D pathTexture, int pathLength) {
     
     int j = int(mod(float(i + 1), float(pathLength)));
     
-    vec2 pi = getLassoPoint(pathTexture, i, pathLength);
-    vec2 pj = getLassoPoint(pathTexture, j, pathLength);
+    vec2 pi = getPolygonPoint(pathTexture, i, pathLength);
+    vec2 pj = getPolygonPoint(pathTexture, j, pathLength);
     
     if (((pi.y > point.y) != (pj.y > point.y)) &&
         (point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y) + pi.x)) {
@@ -10522,7 +10522,7 @@ void main() {
   gl_FragColor = vec4(0.0, 0.0, pointPosition.rg);
   
   
-  if (pointInPolygon(screenPos, lassoPathTexture, lassoPathLength)) {
+  if (pointInPolygon(screenPos, polygonPathTexture, polygonPathLength)) {
     gl_FragColor.r = 1.0;
   }
 }`, zg = `precision mediump float;
@@ -10786,7 +10786,7 @@ void main() {
 }`;
 class Vg extends dn {
   constructor() {
-    super(...arguments), this.lassoPathLength = 0;
+    super(...arguments), this.polygonPathLength = 0;
   }
   updatePositions() {
     const { reglInstance: e, store: n, data: r, config: { rescalePositions: i, enableSimulation: o } } = this, { pointsTextureSize: u } = n;
@@ -10939,7 +10939,7 @@ class Vg extends dn {
         scalePointsOnZoom: () => n.scalePointsOnZoom,
         maxPointSize: () => r.maxPointSize
       }
-    })), this.findPointsOnLassoSelectionCommand || (this.findPointsOnLassoSelectionCommand = e({
+    })), this.findPointsOnPolygonSelectionCommand || (this.findPointsOnPolygonSelectionCommand = e({
       frag: Lg,
       vert: bt,
       framebuffer: () => this.selectedFbo,
@@ -10953,8 +10953,8 @@ class Vg extends dn {
         spaceSize: () => r.adjustedSpaceSize,
         screenSize: () => r.screenSize,
         transformationMatrix: () => r.transform,
-        lassoPathTexture: () => this.lassoPathTexture,
-        lassoPathLength: () => this.lassoPathLength
+        polygonPathTexture: () => this.polygonPathTexture,
+        polygonPathLength: () => this.polygonPathLength
       }
     })), this.clearHoveredFboCommand || (this.clearHoveredFboCommand = e({
       frag: $n,
@@ -11164,14 +11164,14 @@ class Vg extends dn {
     var e;
     (e = this.findPointsOnAreaSelectionCommand) == null || e.call(this);
   }
-  findPointsOnLassoSelection() {
+  findPointsOnPolygonSelection() {
     var e;
-    (e = this.findPointsOnLassoSelectionCommand) == null || e.call(this);
+    (e = this.findPointsOnPolygonSelectionCommand) == null || e.call(this);
   }
-  updateLassoPath(e) {
+  updatePolygonPath(e) {
     const { reglInstance: n } = this;
-    if (this.lassoPathLength = e.length, e.length === 0) {
-      this.lassoPathTexture = void 0, this.lassoPathFbo = void 0;
+    if (this.polygonPathLength = e.length, e.length === 0) {
+      this.polygonPathTexture = void 0, this.polygonPathFbo = void 0;
       return;
     }
     const r = Math.ceil(Math.sqrt(e.length)), i = new Float32Array(r * r * 4);
@@ -11179,13 +11179,13 @@ class Vg extends dn {
       const [s, f] = u;
       i[o * 4] = s, i[o * 4 + 1] = f, i[o * 4 + 2] = 0, i[o * 4 + 3] = 0;
     }
-    this.lassoPathTexture || (this.lassoPathTexture = n.texture()), this.lassoPathTexture({
+    this.polygonPathTexture || (this.polygonPathTexture = n.texture()), this.polygonPathTexture({
       data: i,
       width: r,
       height: r,
       type: "float"
-    }), this.lassoPathFbo || (this.lassoPathFbo = n.framebuffer()), this.lassoPathFbo({
-      color: this.lassoPathTexture,
+    }), this.polygonPathFbo || (this.polygonPathFbo = n.framebuffer()), this.polygonPathFbo({
+      color: this.polygonPathTexture,
       depth: !1,
       stencil: !1
     });
@@ -12851,28 +12851,39 @@ class Wy {
    * The `top` and `bottom` coordinates should be from 0 to the height of the canvas.
    * @returns A Float32Array containing the indices of points inside a rectangular area.
    */
-  getPointsInRange(e) {
+  getPointsInRect(e) {
     if (this._isDestroyed || !this.reglInstance || !this.points) return new Float32Array();
     const n = this.store.screenSize[1];
     return this.store.selectedArea = [[e[0][0], n - e[1][1]], [e[1][0], n - e[0][1]]], this.points.findPointsOnAreaSelection(), tn(this.reglInstance, this.points.selectedFbo).map((i, o) => o % 4 === 0 && i !== 0 ? o / 4 : -1).filter((i) => i !== -1);
   }
   /**
-   * Get points indices inside a lasso (polygon) area.
-   * @param lassoPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the lasso polygon.
+   * Get points indices inside a rectangular area.
+   * @param selection - Array of two corner points `[[left, top], [right, bottom]]`.
+   * The `left` and `right` coordinates should be from 0 to the width of the canvas.
+   * The `top` and `bottom` coordinates should be from 0 to the height of the canvas.
+   * @returns A Float32Array containing the indices of points inside a rectangular area.
+   * @deprecated Use `getPointsInRect` instead. This method will be removed in a future version.
+   */
+  getPointsInRange(e) {
+    return this.getPointsInRect(e);
+  }
+  /**
+   * Get points indices inside a polygon area.
+   * @param polygonPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the polygon.
    * The coordinates should be from 0 to the width/height of the canvas.
-   * @returns A Float32Array containing the indices of points inside the lasso area.
+   * @returns A Float32Array containing the indices of points inside the polygon area.
    */
-  getPointsInLasso(e) {
+  getPointsInPolygon(e) {
     if (this._isDestroyed || !this.reglInstance || !this.points) return new Float32Array();
     if (e.length < 3) return new Float32Array();
     const n = this.store.screenSize[1], r = e.map(([o, u]) => [o, n - u]);
-    return this.points.updateLassoPath(r), this.points.findPointsOnLassoSelection(), tn(this.reglInstance, this.points.selectedFbo).map((o, u) => u % 4 === 0 && o !== 0 ? u / 4 : -1).filter((o) => o !== -1);
+    return this.points.updatePolygonPath(r), this.points.findPointsOnPolygonSelection(), tn(this.reglInstance, this.points.selectedFbo).map((o, u) => u % 4 === 0 && o !== 0 ? u / 4 : -1).filter((o) => o !== -1);
   }
   /** Select points inside a rectangular area.
    * @param selection - Array of two corner points `[[left, top], [right, bottom]]`.
    * The `left` and `right` coordinates should be from 0 to the width of the canvas.
    * The `top` and `bottom` coordinates should be from 0 to the height of the canvas. */
-  selectPointsInRange(e) {
+  selectPointsInRect(e) {
     if (!(this._isDestroyed || !this.reglInstance || !this.points)) {
       if (e) {
         const n = this.store.screenSize[1];
@@ -12884,19 +12895,28 @@ class Wy {
       this.points.updateGreyoutStatus();
     }
   }
-  /** Select points inside a lasso (polygon) area.
-   * @param lassoPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the lasso polygon.
+  /** Select points inside a rectangular area.
+   * @param selection - Array of two corner points `[[left, top], [right, bottom]]`.
+   * The `left` and `right` coordinates should be from 0 to the width of the canvas.
+   * The `top` and `bottom` coordinates should be from 0 to the height of the canvas.
+   * @deprecated Use `selectPointsInRect` instead. This method will be removed in a future version.
+   */
+  selectPointsInRange(e) {
+    return this.selectPointsInRect(e);
+  }
+  /** Select points inside a polygon area.
+   * @param polygonPath - Array of points `[[x1, y1], [x2, y2], ..., [xn, yn]]` that defines the polygon.
    * The coordinates should be from 0 to the width/height of the canvas.
    * Set to null to clear selection. */
-  selectPointsInLasso(e) {
+  selectPointsInPolygon(e) {
     if (!(this._isDestroyed || !this.reglInstance || !this.points)) {
       if (e) {
         if (e.length < 3) {
-          console.warn("Lasso path requires at least 3 points to form a polygon.");
+          console.warn("Polygon path requires at least 3 points to form a polygon.");
           return;
         }
         const n = this.store.screenSize[1], r = e.map(([o, u]) => [o, n - u]);
-        this.points.updateLassoPath(r), this.points.findPointsOnLassoSelection();
+        this.points.updatePolygonPath(r), this.points.findPointsOnPolygonSelection();
         const i = tn(this.reglInstance, this.points.selectedFbo);
         this.store.selectedIndices = i.map((o, u) => u % 4 === 0 && o !== 0 ? u / 4 : -1).filter((o) => o !== -1);
       } else