@m4l/gclick 0.3.0 → 0.3.1-beta.0

package/not_recognized/index.js

@@ -0,0 +1,241 @@
+const ARRAY_TYPES = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+];
+const VERSION = 1;
+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 !== 219) {
+      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 & 15];
+    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(`Unpexpected 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) {
+      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 {
+      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;
+      new Uint8Array(this.data, 0, 2).set([219, (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}.`);
+    }
+    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 = [];
+    while (stack.length) {
+      const axis = stack.pop() || 0;
+      const right = stack.pop() || 0;
+      const left = stack.pop() || 0;
+      if (right - left <= nodeSize) {
+        for (let i = left; i <= right; i++) {
+          const x2 = coords[2 * i];
+          const y2 = coords[2 * i + 1];
+          if (x2 >= minX && x2 <= maxX && y2 >= minY && y2 <= maxY) result.push(ids[i]);
+        }
+        continue;
+      }
+      const m = left + right >> 1;
+      const x = coords[2 * m];
+      const y = coords[2 * m + 1];
+      if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[m]);
+      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;
+    while (stack.length) {
+      const axis = stack.pop() || 0;
+      const right = stack.pop() || 0;
+      const left = stack.pop() || 0;
+      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;
+      }
+      const m = left + right >> 1;
+      const x = coords[2 * m];
+      const y = coords[2 * m + 1];
+      if (sqDist(x, y, qx, qy) <= r2) result.push(ids[m]);
+      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;
+  }
+}
+function sort(ids, coords, nodeSize, left, right, axis) {
+  if (right - left <= nodeSize) return;
+  const m = left + right >> 1;
+  select(ids, coords, m, left, right, axis);
+  sort(ids, coords, nodeSize, left, m - 1, 1 - axis);
+  sort(ids, coords, nodeSize, m + 1, right, 1 - 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;
+  }
+}
+function swapItem(ids, coords, i, j) {
+  swap(ids, i, j);
+  swap(coords, 2 * i, 2 * j);
+  swap(coords, 2 * i + 1, 2 * j + 1);
+}
+function swap(arr, i, j) {
+  const tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}
+function sqDist(ax, ay, bx, by) {
+  const dx = ax - bx;
+  const dy = ay - by;
+  return dx * dx + dy * dy;
+}
+export {
+  KDBush as K
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m4l/gclick",
-  "version": "0.3.0",
+  "version": "0.3.1-beta.0",
   "license": "UNLICENSED",
   "lint-staged": {
     "*.{js,ts,tsx}": "eslint --fix --max-warnings 0  --no-warn-ignored"
@@ -15,7 +15,23 @@
     "@mui/system": "5.16.7",
     "@mui/x-charts": "8.10.2",
     "@mui/x-date-pickers": "6.20.2",
-    "lodash-es": "4.17.21",
+    "@types/lodash-es": "^4.17.12",
+    "atmosphere.js": "^4.0.0",
+    "chart.js": "^4.4.0",
+    "chartjs-chart-error-bars": "^4.3.3",
+    "eventemitter3": "^4.0.7",
+    "fast-equals": "^5.0.1",
+    "history": "5.3.0",
+    "install": "^0.13.0",
+    "jwt-decode": "^4.0.0",
+    "kdbush": "^4.0.2",
+    "leaflet": "^1.9.4",
+    "leaflet-polylinedecorator": "^1.6.0",
+    "leaflet.markercluster": "^1.5.3",
+    "lodash-es": "^4.17.21",
+    "nprogress": "^0.2.0",
+    "qrcode.react": "^3.1.0",
+    "rbush": "^4.0.1",
     "react": "18.3.1",
     "react-dom": "18.3.1",
     "react-leaflet": "^4.2.1"