@hema-to/regl-scatterplot 1.14.1

package/src/kdbush-class.js

@@ -0,0 +1,369 @@
+/**
+ * KDBush - A fast static index for 2D points
+ * @license ISC License
+ * @copyright Vladimir Agafonkin 2018
+ * @version 4.0.2
+ * @see https://github.com/mourner/kdbush/
+ */
+export default () => {
+  const ARRAY_TYPES = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+  ];
+
+  /** @typedef {Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor} TypedArrayConstructor */
+
+  const VERSION = 1; // serialized format version
+  const HEADER_SIZE = 8;
+
+  class KDBush {
+    /**
+     * Creates an index from raw `ArrayBuffer` data.
+     * @param {ArrayBuffer} data
+     */
+    static from(data) {
+      if (!(data instanceof ArrayBuffer)) {
+        throw new Error('Data must be an instance of ArrayBuffer.');
+      }
+      const [magic, versionAndType] = new Uint8Array(data, 0, 2);
+      if (magic !== 0xdb) {
+        throw new Error('Data does not appear to be in a KDBush format.');
+      }
+      const version = versionAndType >> 4;
+      if (version !== VERSION) {
+        throw new Error(`Got v${version} data when expected v${VERSION}.`);
+      }
+      const ArrayType = ARRAY_TYPES[versionAndType & 0x0f];
+      if (!ArrayType) {
+        throw new Error('Unrecognized array type.');
+      }
+      const [nodeSize] = new Uint16Array(data, 2, 1);
+      const [numItems] = new Uint32Array(data, 4, 1);
+
+      return new KDBush(numItems, nodeSize, ArrayType, data);
+    }
+
+    /**
+     * Creates an index that will hold a given number of items.
+     * @param {number} numItems
+     * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
+     * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+     * @param {ArrayBuffer} [data] (For internal use only)
+     */
+    constructor(numItems, nodeSize = 64, ArrayType = Float64Array, data) {
+      if (isNaN(numItems) || numItems < 0)
+        throw new Error(`Unexpected numItems value: ${numItems}.`);
+
+      this.numItems = +numItems;
+      this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
+      this.ArrayType = ArrayType;
+      this.IndexArrayType = numItems < 65536 ? Uint16Array : Uint32Array;
+
+      const arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
+      const coordsByteSize = numItems * 2 * this.ArrayType.BYTES_PER_ELEMENT;
+      const idsByteSize = numItems * this.IndexArrayType.BYTES_PER_ELEMENT;
+      const padCoords = (8 - (idsByteSize % 8)) % 8;
+
+      if (arrayTypeIndex < 0) {
+        throw new Error(`Unexpected typed array class: ${ArrayType}.`);
+      }
+
+      if (data && data instanceof ArrayBuffer) {
+        // reconstruct an index from a buffer
+        this.data = data;
+        this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
+        this.coords = new this.ArrayType(
+          this.data,
+          HEADER_SIZE + idsByteSize + padCoords,
+          numItems * 2
+        );
+        this._pos = numItems * 2;
+        this._finished = true;
+      } else {
+        // initialize a new index
+        this.data = new ArrayBuffer(
+          HEADER_SIZE + coordsByteSize + idsByteSize + padCoords
+        );
+        this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
+        this.coords = new this.ArrayType(
+          this.data,
+          HEADER_SIZE + idsByteSize + padCoords,
+          numItems * 2
+        );
+        this._pos = 0;
+        this._finished = false;
+
+        // set header
+        new Uint8Array(this.data, 0, 2).set([
+          0xdb,
+          (VERSION << 4) + arrayTypeIndex,
+        ]);
+        new Uint16Array(this.data, 2, 1)[0] = nodeSize;
+        new Uint32Array(this.data, 4, 1)[0] = numItems;
+      }
+    }
+
+    /**
+     * Add a point to the index.
+     * @param {number} x
+     * @param {number} y
+     * @returns {number} An incremental index associated with the added item (starting from `0`).
+     */
+    add(x, y) {
+      const index = this._pos >> 1;
+      this.ids[index] = index;
+      this.coords[this._pos++] = x;
+      this.coords[this._pos++] = y;
+      return index;
+    }
+
+    /**
+     * Perform indexing of the added points.
+     */
+    finish() {
+      const numAdded = this._pos >> 1;
+      if (numAdded !== this.numItems) {
+        throw new Error(
+          `Added ${numAdded} items when expected ${this.numItems}.`
+        );
+      }
+      // kd-sort both arrays for efficient search
+      sort(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0);
+
+      this._finished = true;
+      return this;
+    }
+
+    /**
+     * Search the index for items within a given bounding box.
+     * @param {number} minX
+     * @param {number} minY
+     * @param {number} maxX
+     * @param {number} maxY
+     * @returns {number[]} An array of indices correponding to the found items.
+     */
+    range(minX, minY, maxX, maxY) {
+      if (!this._finished)
+        throw new Error('Data not yet indexed - call index.finish().');
+
+      const { ids, coords, nodeSize } = this;
+      const stack = [0, ids.length - 1, 0];
+      const result = [];
+
+      // recursively search for items in range in the kd-sorted arrays
+      while (stack.length) {
+        const axis = stack.pop() || 0;
+        const right = stack.pop() || 0;
+        const left = stack.pop() || 0;
+
+        // if we reached "tree node", search linearly
+        if (right - left <= nodeSize) {
+          for (let i = left; i <= right; i++) {
+            const x = coords[2 * i];
+            const y = coords[2 * i + 1];
+            if (x >= minX && x <= maxX && y >= minY && y <= maxY)
+              result.push(ids[i]);
+          }
+          continue;
+        }
+
+        // otherwise find the middle index
+        const m = (left + right) >> 1;
+
+        // include the middle item if it's in range
+        const x = coords[2 * m];
+        const y = coords[2 * m + 1];
+        if (x >= minX && x <= maxX && y >= minY && y <= maxY)
+          result.push(ids[m]);
+
+        // queue search in halves that intersect the query
+        if (axis === 0 ? minX <= x : minY <= y) {
+          stack.push(left);
+          stack.push(m - 1);
+          stack.push(1 - axis);
+        }
+        if (axis === 0 ? maxX >= x : maxY >= y) {
+          stack.push(m + 1);
+          stack.push(right);
+          stack.push(1 - axis);
+        }
+      }
+
+      return result;
+    }
+
+    /**
+     * Search the index for items within a given radius.
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} r Query radius.
+     * @returns {number[]} An array of indices correponding to the found items.
+     */
+    within(qx, qy, r) {
+      if (!this._finished)
+        throw new Error('Data not yet indexed - call index.finish().');
+
+      const { ids, coords, nodeSize } = this;
+      const stack = [0, ids.length - 1, 0];
+      const result = [];
+      const r2 = r * r;
+
+      // recursively search for items within radius in the kd-sorted arrays
+      while (stack.length) {
+        const axis = stack.pop() || 0;
+        const right = stack.pop() || 0;
+        const left = stack.pop() || 0;
+
+        // if we reached "tree node", search linearly
+        if (right - left <= nodeSize) {
+          for (let i = left; i <= right; i++) {
+            if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2)
+              result.push(ids[i]);
+          }
+          continue;
+        }
+
+        // otherwise find the middle index
+        const m = (left + right) >> 1;
+
+        // include the middle item if it's in range
+        const x = coords[2 * m];
+        const y = coords[2 * m + 1];
+        if (sqDist(x, y, qx, qy) <= r2) result.push(ids[m]);
+
+        // queue search in halves that intersect the query
+        if (axis === 0 ? qx - r <= x : qy - r <= y) {
+          stack.push(left);
+          stack.push(m - 1);
+          stack.push(1 - axis);
+        }
+        if (axis === 0 ? qx + r >= x : qy + r >= y) {
+          stack.push(m + 1);
+          stack.push(right);
+          stack.push(1 - axis);
+        }
+      }
+
+      return result;
+    }
+  }
+
+  /**
+   * @param {Uint16Array | Uint32Array} ids
+   * @param {InstanceType<TypedArrayConstructor>} coords
+   * @param {number} nodeSize
+   * @param {number} left
+   * @param {number} right
+   * @param {number} axis
+   */
+  function sort(ids, coords, nodeSize, left, right, axis) {
+    if (right - left <= nodeSize) return;
+
+    const m = (left + right) >> 1; // middle index
+
+    // sort ids and coords around the middle index so that the halves lie
+    // either left/right or top/bottom correspondingly (taking turns)
+    select(ids, coords, m, left, right, axis);
+
+    // recursively kd-sort first half and second half on the opposite axis
+    sort(ids, coords, nodeSize, left, m - 1, 1 - axis);
+    sort(ids, coords, nodeSize, m + 1, right, 1 - axis);
+  }
+
+  /**
+   * Custom Floyd-Rivest selection algorithm: sort ids and coords so that
+   * [left..k-1] items are smaller than k-th item (on either x or y axis)
+   * @param {Uint16Array | Uint32Array} ids
+   * @param {InstanceType<TypedArrayConstructor>} coords
+   * @param {number} k
+   * @param {number} left
+   * @param {number} right
+   * @param {number} axis
+   */
+  function select(ids, coords, k, left, right, axis) {
+    while (right > left) {
+      if (right - left > 600) {
+        const n = right - left + 1;
+        const m = k - left + 1;
+        const z = Math.log(n);
+        const s = 0.5 * Math.exp((2 * z) / 3);
+        const sd =
+          0.5 * Math.sqrt((z * s * (n - s)) / n) * (m - n / 2 < 0 ? -1 : 1);
+        const newLeft = Math.max(left, Math.floor(k - (m * s) / n + sd));
+        const newRight = Math.min(
+          right,
+          Math.floor(k + ((n - m) * s) / n + sd)
+        );
+        select(ids, coords, k, newLeft, newRight, axis);
+      }
+
+      const t = coords[2 * k + axis];
+      let i = left;
+      let j = right;
+
+      swapItem(ids, coords, left, k);
+      if (coords[2 * right + axis] > t) swapItem(ids, coords, left, right);
+
+      while (i < j) {
+        swapItem(ids, coords, i, j);
+        i++;
+        j--;
+        while (coords[2 * i + axis] < t) i++;
+        while (coords[2 * j + axis] > t) j--;
+      }
+
+      if (coords[2 * left + axis] === t) swapItem(ids, coords, left, j);
+      else {
+        j++;
+        swapItem(ids, coords, j, right);
+      }
+
+      if (j <= k) left = j + 1;
+      if (k <= j) right = j - 1;
+    }
+  }
+
+  /**
+   * @param {Uint16Array | Uint32Array} ids
+   * @param {InstanceType<TypedArrayConstructor>} coords
+   * @param {number} i
+   * @param {number} j
+   */
+  function swapItem(ids, coords, i, j) {
+    swap(ids, i, j);
+    swap(coords, 2 * i, 2 * j);
+    swap(coords, 2 * i + 1, 2 * j + 1);
+  }
+
+  /**
+   * @param {InstanceType<TypedArrayConstructor>} arr
+   * @param {number} i
+   * @param {number} j
+   */
+  function swap(arr, i, j) {
+    const tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+  }
+
+  /**
+   * @param {number} ax
+   * @param {number} ay
+   * @param {number} bx
+   * @param {number} by
+   */
+  function sqDist(ax, ay, bx, by) {
+    const dx = ax - bx;
+    const dy = ay - by;
+    return dx * dx + dy * dy;
+  }
+
+  return KDBush;
+};

package/src/kdbush-worker.js

@@ -0,0 +1,20 @@
+export default () => {
+  addEventListener('message', (event) => {
+    const points = event.data.points;
+
+    if (points.length === 0) {
+      self.postMessage({ error: new Error('Invalid point data') });
+    }
+
+    // biome-ignore lint/correctness/noUndeclaredVariables: KDBush is made available during compilation
+    const index = new KDBush(points.length, event.data.nodeSize);
+
+    for (const [x, y] of points) {
+      index.add(x, y);
+    }
+
+    index.finish();
+
+    postMessage(index.data, [index.data]);
+  });
+};

package/src/kdbush.js

@@ -0,0 +1,69 @@
+// biome-ignore lint/style/useNamingConvention: KDBush is a library name
+import createKDBushClass from './kdbush-class.js';
+import workerFn from './kdbush-worker.js';
+
+// biome-ignore lint/style/useNamingConvention: KDBush is a library name
+const KDBush = createKDBushClass();
+const WORKER_THRESHOLD = 1000000;
+
+const createWorker = (fn) => {
+  const kdbushStr = createKDBushClass.toString();
+  const fnStr = fn.toString();
+  const workerStr =
+    // biome-ignore lint/style/useTemplate: Prefer one assignment per line
+    `const createKDBushClass = ${kdbushStr};` +
+    'KDBush = createKDBushClass();' +
+    `const createWorker = ${fnStr};` +
+    'createWorker();';
+
+  const blob = new Blob([workerStr], { type: 'text/javascript' });
+  const workerUrl = URL.createObjectURL(blob);
+  const worker = new Worker(workerUrl, { name: 'KDBush' });
+
+  // Clean up URL
+  URL.revokeObjectURL(workerUrl);
+
+  return worker;
+};
+
+/**
+ * Create KDBush from an either point data or an existing spatial index
+ * @param {import('./types').Points | ArrayBuffer} pointsOrIndex - Points or KDBush index
+ * @param {Partial<import('./types').CreateKDBushOptions>} options - Options for configuring the index and its creation
+ * @return {Promise<KDBush>} KDBush instance
+ */
+const createKdbush = (
+  pointsOrIndex,
+  options = { nodeSize: 16, useWorker: undefined },
+) =>
+  new Promise((resolve, reject) => {
+    if (pointsOrIndex instanceof ArrayBuffer) {
+      resolve(KDBush.from(pointsOrIndex));
+    } else if (
+      (pointsOrIndex.length < WORKER_THRESHOLD ||
+        options.useWorker === false) &&
+      options.useWorker !== true
+    ) {
+      const index = new KDBush(pointsOrIndex.length, options.nodeSize);
+      for (const pointOrIndex of pointsOrIndex) {
+        index.add(pointOrIndex[0], pointOrIndex[1]);
+      }
+      index.finish();
+      resolve(index);
+    } else {
+      const worker = createWorker(workerFn);
+
+      worker.onmessage = (e) => {
+        if (e.data.error) {
+          reject(e.data.error);
+        } else {
+          resolve(KDBush.from(e.data));
+        }
+        worker.terminate();
+      };
+
+      worker.postMessage({ points: pointsOrIndex, nodeSize: options.nodeSize });
+    }
+  });
+
+export default createKdbush;

package/src/lasso-manager/constants.js

@@ -0,0 +1,7 @@
+export const DEFAULT_LASSO_START_INITIATOR_SHOW = true;
+export const DEFAULT_LASSO_MIN_DELAY = 8;
+export const DEFAULT_LASSO_MIN_DIST = 2;
+export const DEFAULT_LASSO_TYPE = 'freeform';
+export const DEFAULT_BRUSH_SIZE = 24;
+export const LASSO_SHOW_START_INITIATOR_TIME = 2500;
+export const LASSO_HIDE_START_INITIATOR_TIME = 250;