@mapgis/supercluster 16.6.0 → 17.0.0

package/dist/supercluster.js

@@ -0,0 +1,661 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+typeof define === 'function' && define.amd ? define(factory) :
+(global = global || self, global.Supercluster = factory());
+}(this, (function () { 'use strict';
+
+function sortKD(ids, coords, nodeSize, left, right, depth) {
+    if (right - left <= nodeSize) { return; }
+
+    var m = (left + right) >> 1;
+
+    select(ids, coords, m, left, right, depth % 2);
+
+    sortKD(ids, coords, nodeSize, left, m - 1, depth + 1);
+    sortKD(ids, coords, nodeSize, m + 1, right, depth + 1);
+}
+
+function select(ids, coords, k, left, right, inc) {
+
+    while (right > left) {
+        if (right - left > 600) {
+            var n = right - left + 1;
+            var m = k - left + 1;
+            var z = Math.log(n);
+            var s = 0.5 * Math.exp(2 * z / 3);
+            var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+            var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+            var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+            select(ids, coords, k, newLeft, newRight, inc);
+        }
+
+        var t = coords[2 * k + inc];
+        var i = left;
+        var j = right;
+
+        swapItem(ids, coords, left, k);
+        if (coords[2 * right + inc] > t) { swapItem(ids, coords, left, right); }
+
+        while (i < j) {
+            swapItem(ids, coords, i, j);
+            i++;
+            j--;
+            while (coords[2 * i + inc] < t) { i++; }
+            while (coords[2 * j + inc] > t) { j--; }
+        }
+
+        if (coords[2 * left + inc] === 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) {
+    var tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+}
+
+function range(ids, coords, minX, minY, maxX, maxY, nodeSize) {
+    var stack = [0, ids.length - 1, 0];
+    var result = [];
+    var x, y;
+
+    while (stack.length) {
+        var axis = stack.pop();
+        var right = stack.pop();
+        var left = stack.pop();
+
+        if (right - left <= nodeSize) {
+            for (var i = left; i <= right; i++) {
+                x = coords[2 * i];
+                y = coords[2 * i + 1];
+                if (x >= minX && x <= maxX && y >= minY && y <= maxY) { result.push(ids[i]); }
+            }
+            continue;
+        }
+
+        var m = Math.floor((left + right) / 2);
+
+        x = coords[2 * m];
+        y = coords[2 * m + 1];
+
+        if (x >= minX && x <= maxX && y >= minY && y <= maxY) { result.push(ids[m]); }
+
+        var nextAxis = (axis + 1) % 2;
+
+        if (axis === 0 ? minX <= x : minY <= y) {
+            stack.push(left);
+            stack.push(m - 1);
+            stack.push(nextAxis);
+        }
+        if (axis === 0 ? maxX >= x : maxY >= y) {
+            stack.push(m + 1);
+            stack.push(right);
+            stack.push(nextAxis);
+        }
+    }
+
+    return result;
+}
+
+function within(ids, coords, qx, qy, r, nodeSize) {
+    var stack = [0, ids.length - 1, 0];
+    var result = [];
+    var r2 = r * r;
+
+    while (stack.length) {
+        var axis = stack.pop();
+        var right = stack.pop();
+        var left = stack.pop();
+
+        if (right - left <= nodeSize) {
+            for (var i = left; i <= right; i++) {
+                if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2) { result.push(ids[i]); }
+            }
+            continue;
+        }
+
+        var m = Math.floor((left + right) / 2);
+
+        var x = coords[2 * m];
+        var y = coords[2 * m + 1];
+
+        if (sqDist(x, y, qx, qy) <= r2) { result.push(ids[m]); }
+
+        var nextAxis = (axis + 1) % 2;
+
+        if (axis === 0 ? qx - r <= x : qy - r <= y) {
+            stack.push(left);
+            stack.push(m - 1);
+            stack.push(nextAxis);
+        }
+        if (axis === 0 ? qx + r >= x : qy + r >= y) {
+            stack.push(m + 1);
+            stack.push(right);
+            stack.push(nextAxis);
+        }
+    }
+
+    return result;
+}
+
+function sqDist(ax, ay, bx, by) {
+    var dx = ax - bx;
+    var dy = ay - by;
+    return dx * dx + dy * dy;
+}
+
+var defaultGetX = function (p) { return p[0]; };
+var defaultGetY = function (p) { return p[1]; };
+
+var KDBush = function KDBush(points, getX, getY, nodeSize, ArrayType) {
+    if ( getX === void 0 ) getX = defaultGetX;
+    if ( getY === void 0 ) getY = defaultGetY;
+    if ( nodeSize === void 0 ) nodeSize = 64;
+    if ( ArrayType === void 0 ) ArrayType = Float64Array;
+
+    this.nodeSize = nodeSize;
+    this.points = points;
+
+    var IndexArrayType = points.length < 65536 ? Uint16Array : Uint32Array;
+
+    var ids = this.ids = new IndexArrayType(points.length);
+    var coords = this.coords = new ArrayType(points.length * 2);
+
+    for (var i = 0; i < points.length; i++) {
+        ids[i] = i;
+        coords[2 * i] = getX(points[i]);
+        coords[2 * i + 1] = getY(points[i]);
+    }
+
+    sortKD(ids, coords, nodeSize, 0, ids.length - 1, 0);
+};
+
+KDBush.prototype.range = function range$1 (minX, minY, maxX, maxY) {
+    return range(this.ids, this.coords, minX, minY, maxX, maxY, this.nodeSize);
+};
+
+KDBush.prototype.within = function within$1 (x, y, r) {
+    return within(this.ids, this.coords, x, y, r, this.nodeSize);
+};
+
+var defaultOptions = {
+    crs: 'EPSG:3857',  // 默认3857
+    minZoom: 0,   // min zoom to generate clusters on
+    maxZoom: 16,  // max zoom level to cluster the points on
+    minPoints: 2, // minimum points to form a cluster
+    radius: 40,   // cluster radius in pixels
+    extent: 512,  // tile extent (radius is calculated relative to it)
+    nodeSize: 64, // size of the KD-tree leaf node, affects performance
+    log: false,   // whether to log timing info
+
+    // whether to generate numeric ids for input features (in vector tiles)
+    generateId: false,
+
+    // a reduce function for calculating custom cluster properties
+    reduce: null, // (accumulated, props) => { accumulated.sum += props.sum; }
+
+    // properties to use for individual points when running the reducer
+    map: function (props) { return props; } // props => ({sum: props.my_value})
+};
+
+var Supercluster = function Supercluster(options) {
+    this.options = extend(Object.create(defaultOptions), options);
+    this.trees = new Array(this.options.maxZoom + 1);
+};
+
+Supercluster.prototype.load = function load (points) {
+    var ref = this.options;
+        var log = ref.log;
+        var minZoom = ref.minZoom;
+        var maxZoom = ref.maxZoom;
+        var nodeSize = ref.nodeSize;
+        var crs = ref.crs;
+
+    if (log) { console.time('total time'); }
+
+    var timerId = "prepare " + (points.length) + " points";
+    if (log) { console.time(timerId); }
+
+    this.points = points;
+
+    // generate a cluster object for each point and index input points into a KD-tree
+    var clusters = [];
+    for (var i = 0; i < points.length; i++) {
+        if (!points[i].geometry) { continue; }
+        clusters.push(createPointCluster(points[i], i, crs));
+    }
+    this.trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+
+    if (log) { console.timeEnd(timerId); }
+
+    // cluster points on max zoom, then cluster the results on previous zoom, etc.;
+    // results in a cluster hierarchy across zoom levels
+    for (var z = maxZoom; z >= minZoom; z--) {
+        var now = +Date.now();
+
+        // create a new set of clusters for the zoom and index them with a KD-tree
+        clusters = this._cluster(clusters, z);
+        this.trees[z] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+
+        if (log) { console.log('z%d: %d clusters in %dms', z, clusters.length, +Date.now() - now); }
+    }
+
+    if (log) { console.timeEnd('total time'); }
+
+    return this;
+};
+
+Supercluster.prototype.getClusters = function getClusters (bbox, zoom) {
+    var crs = this.crs;
+    var minLng = ((bbox[0] + 180) % 360 + 360) % 360 - 180;
+    var minLat = Math.max(-90, Math.min(90, bbox[1]));
+    var maxLng = bbox[2] === 180 ? 180 : ((bbox[2] + 180) % 360 + 360) % 360 - 180;
+    var maxLat = Math.max(-90, Math.min(90, bbox[3]));
+
+    if (bbox[2] - bbox[0] >= 360) {
+        minLng = -180;
+        maxLng = 180;
+    } else if (minLng > maxLng) {
+        var easternHem = this.getClusters([minLng, minLat, 180, maxLat], zoom);
+        var westernHem = this.getClusters([-180, minLat, maxLng, maxLat], zoom);
+        return easternHem.concat(westernHem);
+    }
+
+    var tree = this.trees[this._limitZoom(zoom)];
+    var ids = tree.range(lngX(minLng, crs), latY(maxLat, crs), lngX(maxLng, crs), latY(minLat, crs));
+    var clusters = [];
+    for (var i = 0, list = ids; i < list.length; i += 1) {
+        var id = list[i];
+
+            var c = tree.points[id];
+        clusters.push(c.numPoints ? getClusterJSON(c, crs) : this.points[c.index]);
+    }
+    return clusters;
+};
+
+Supercluster.prototype.getChildren = function getChildren (clusterId) {
+    var crs = this.crs;
+    var originId = this._getOriginId(clusterId);
+    var originZoom = this._getOriginZoom(clusterId);
+    var errorMsg = 'No cluster with the specified id.';
+
+    var index = this.trees[originZoom];
+    if (!index) { throw new Error(errorMsg); }
+
+    var origin = index.points[originId];
+    if (!origin) { throw new Error(errorMsg); }
+
+    var r = this.options.radius / (this.options.extent * Math.pow(2, originZoom - 1));
+    var ids = index.within(origin.x, origin.y, r);
+    var children = [];
+    for (var i = 0, list = ids; i < list.length; i += 1) {
+        var id = list[i];
+
+            var c = index.points[id];
+        if (c.parentId === clusterId) {
+            children.push(c.numPoints ? getClusterJSON(c, crs) : this.points[c.index]);
+        }
+    }
+
+    if (children.length === 0) { throw new Error(errorMsg); }
+
+    return children;
+};
+
+Supercluster.prototype.getLeaves = function getLeaves (clusterId, limit, offset) {
+    limit = limit || 10;
+    offset = offset || 0;
+
+    var leaves = [];
+    this._appendLeaves(leaves, clusterId, limit, offset, 0);
+
+    return leaves;
+};
+
+Supercluster.prototype.getTile = function getTile (z, x, y) {
+    var tree = this.trees[this._limitZoom(z)];
+    var z2 = Math.pow(2, z);
+    var ref = this.options;
+        var extent = ref.extent;
+        var radius = ref.radius;
+    var p = radius / extent;
+    var top = (y - p) / z2;
+    var bottom = (y + 1 + p) / z2;
+
+    var tile = {
+        features: []
+    };
+
+    this._addTileFeatures(
+        tree.range((x - p) / z2, top, (x + 1 + p) / z2, bottom),
+        tree.points, x, y, z2, tile);
+
+    if (x === 0) {
+        this._addTileFeatures(
+            tree.range(1 - p / z2, top, 1, bottom),
+            tree.points, z2, y, z2, tile);
+    }
+    if (x === z2 - 1) {
+        this._addTileFeatures(
+            tree.range(0, top, p / z2, bottom),
+            tree.points, -1, y, z2, tile);
+    }
+
+    return tile.features.length ? tile : null;
+};
+
+Supercluster.prototype.getClusterExpansionZoom = function getClusterExpansionZoom (clusterId) {
+    var expansionZoom = this._getOriginZoom(clusterId) - 1;
+    while (expansionZoom <= this.options.maxZoom) {
+        var children = this.getChildren(clusterId);
+        expansionZoom++;
+        if (children.length !== 1) { break; }
+        clusterId = children[0].properties.cluster_id;
+    }
+    return expansionZoom;
+};
+
+Supercluster.prototype._appendLeaves = function _appendLeaves (result, clusterId, limit, offset, skipped) {
+    var children = this.getChildren(clusterId);
+
+    for (var i = 0, list = children; i < list.length; i += 1) {
+        var child = list[i];
+
+            var props = child.properties;
+
+        if (props && props.cluster) {
+            if (skipped + props.point_count <= offset) {
+                // skip the whole cluster
+                skipped += props.point_count;
+            } else {
+                // enter the cluster
+                skipped = this._appendLeaves(result, props.cluster_id, limit, offset, skipped);
+                // exit the cluster
+            }
+        } else if (skipped < offset) {
+            // skip a single point
+            skipped++;
+        } else {
+            // add a single point
+            result.push(child);
+        }
+        if (result.length === limit) { break; }
+    }
+
+    return skipped;
+};
+
+Supercluster.prototype._addTileFeatures = function _addTileFeatures (ids, points, x, y, z2, tile) {
+    for (var i$1 = 0, list = ids; i$1 < list.length; i$1 += 1) {
+        var i = list[i$1];
+
+            var c = points[i];
+        var isCluster = c.numPoints;
+        var f = {
+            type: 1,
+            geometry: [[
+                Math.round(this.options.extent * (c.x * z2 - x)),
+                Math.round(this.options.extent * (c.y * z2 - y))
+            ]],
+            tags: isCluster ? getClusterProperties(c) : this.points[c.index].properties
+        };
+
+        // assign id
+        var id = (void 0);
+        if (isCluster) {
+            id = c.id;
+        } else if (this.options.generateId) {
+            // optionally generate id
+            id = c.index;
+        } else if (this.points[c.index].id) {
+            // keep id if already assigned
+            id = this.points[c.index].id;
+        }
+
+        if (id !== undefined) { f.id = id; }
+
+        tile.features.push(f);
+    }
+};
+
+Supercluster.prototype._limitZoom = function _limitZoom (z) {
+    return Math.max(this.options.minZoom, Math.min(+z, this.options.maxZoom + 1));
+};
+
+Supercluster.prototype._cluster = function _cluster (points, zoom) {
+    var clusters = [];
+    var ref = this.options;
+        var radius = ref.radius;
+        var extent = ref.extent;
+        var reduce = ref.reduce;
+        var minPoints = ref.minPoints;
+    var r = radius / (extent * Math.pow(2, zoom));
+
+    // loop through each point
+    for (var i = 0; i < points.length; i++) {
+        var p = points[i];
+        // if we've already visited the point at this zoom level, skip it
+        if (p.zoom <= zoom) { continue; }
+        p.zoom = zoom;
+
+        // find all nearby points
+        var tree = this.trees[zoom + 1];
+        var neighborIds = tree.within(p.x, p.y, r);
+
+        var numPointsOrigin = p.numPoints || 1;
+        var numPoints = numPointsOrigin;
+
+        // count the number of points in a potential cluster
+        for (var i$1 = 0, list = neighborIds; i$1 < list.length; i$1 += 1) {
+            var neighborId = list[i$1];
+
+                var b = tree.points[neighborId];
+            // filter out neighbors that are already processed
+            if (b.zoom > zoom) { numPoints += b.numPoints || 1; }
+        }
+
+        if (numPoints >= minPoints) { // enough points to form a cluster
+            var wx = p.x * numPointsOrigin;
+            var wy = p.y * numPointsOrigin;
+
+            var clusterProperties = reduce && numPointsOrigin > 1 ? this._map(p, true) : null;
+
+            // encode both zoom and point index on which the cluster originated -- offset by total length of features
+            var id = (i << 5) + (zoom + 1) + this.points.length;
+
+            for (var i$2 = 0, list$1 = neighborIds; i$2 < list$1.length; i$2 += 1) {
+                var neighborId$1 = list$1[i$2];
+
+                    var b$1 = tree.points[neighborId$1];
+
+                if (b$1.zoom <= zoom) { continue; }
+                b$1.zoom = zoom; // save the zoom (so it doesn't get processed twice)
+
+                var numPoints2 = b$1.numPoints || 1;
+                wx += b$1.x * numPoints2; // accumulate coordinates for calculating weighted center
+                wy += b$1.y * numPoints2;
+
+                b$1.parentId = id;
+
+                if (reduce) {
+                    if (!clusterProperties) { clusterProperties = this._map(p, true); }
+                    reduce(clusterProperties, this._map(b$1));
+                }
+            }
+
+            p.parentId = id;
+            clusters.push(createCluster(wx / numPoints, wy / numPoints, id, numPoints, clusterProperties));
+
+        } else { // left points as unclustered
+            clusters.push(p);
+
+            if (numPoints > 1) {
+                for (var i$3 = 0, list$2 = neighborIds; i$3 < list$2.length; i$3 += 1) {
+                    var neighborId$2 = list$2[i$3];
+
+                        var b$2 = tree.points[neighborId$2];
+                    if (b$2.zoom <= zoom) { continue; }
+                    b$2.zoom = zoom;
+                    clusters.push(b$2);
+                }
+            }
+        }
+    }
+
+    return clusters;
+};
+
+// get index of the point from which the cluster originated
+Supercluster.prototype._getOriginId = function _getOriginId (clusterId) {
+    return (clusterId - this.points.length) >> 5;
+};
+
+// get zoom of the point from which the cluster originated
+Supercluster.prototype._getOriginZoom = function _getOriginZoom (clusterId) {
+    return (clusterId - this.points.length) % 32;
+};
+
+Supercluster.prototype._map = function _map (point, clone) {
+    if (point.numPoints) {
+        return clone ? extend({}, point.properties) : point.properties;
+    }
+    var original = this.points[point.index].properties;
+    var result = this.options.map(original);
+    return clone && result === original ? extend({}, result) : result;
+};
+
+function createCluster(x, y, id, numPoints, properties) {
+    return {
+        x: x, // weighted cluster center
+        y: y,
+        zoom: Infinity, // the last zoom the cluster was processed at
+        id: id, // encodes index of the first child of the cluster and its zoom level
+        parentId: -1, // parent cluster id
+        numPoints: numPoints,
+        properties: properties
+    };
+}
+
+function createPointCluster(p, id, crs) {
+    var ref = p.geometry.coordinates;
+    var x = ref[0];
+    var y = ref[1];
+    return {
+        x: lngX(x, crs), // projected point coordinates
+        y: latY(y, crs),
+        zoom: Infinity, // the last zoom the point was processed at
+        index: id, // index of the source feature in the original input array,
+        parentId: -1 // parent cluster id
+    };
+}
+
+function getClusterJSON(cluster, crs) {
+    return {
+        type: 'Feature',
+        id: cluster.id,
+        properties: getClusterProperties(cluster),
+        geometry: {
+            type: 'Point',
+            coordinates: [xLng(cluster.x, crs), yLat(cluster.y, crs)]
+        }
+    };
+}
+
+function getClusterProperties(cluster) {
+    var count = cluster.numPoints;
+    var abbrev =
+        count >= 10000 ? ((Math.round(count / 1000)) + "k") :
+        count >= 1000 ? ((Math.round(count / 100) / 10) + "k") : count;
+    return extend(extend({}, cluster.properties), {
+        cluster: true,
+        cluster_id: cluster.id,
+        point_count: count,
+        point_count_abbreviated: abbrev
+    });
+}
+
+/**
+ * 针对X方向投影
+ * @param {*} lng
+ * @param {*} crs
+ * @returns 返回投影后的坐标，注意这里的坐标不是平面坐标值，而是矩阵值，即 [0 ~ 1]之间
+ */
+function lngX(lng, crs) {
+    var transformX;
+    if (!crs || crs === 'EPSG:3857') {
+        transformX = lng / 360 + 0.5;
+    } else {
+        transformX = lng / 360 + 0.5;
+    }
+    return transformX;
+}
+
+/**
+ * 针对y方向投影
+ * @param {*} lat
+ * @param {*} crs
+ * @returns 返回投影后的坐标，注意这里的坐标不是平面坐标值，而是矩阵值，即 [0 ~ 1]之间
+ */
+function latY(lat, crs) {
+    var transformY;
+    if (!crs || crs === 'EPSG:3857') {
+        var sin = Math.sin(lat * Math.PI / 180);
+        transformY = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+    } else {
+        transformY = (90 - lat) / 360;
+    }
+    return transformY < 0 ? 0 : transformY > 1 ? 1 : transformY;
+    /* const sin = Math.sin(lat * Math.PI / 180);
+    const y = (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);
+    return y < 0 ? 0 : y > 1 ? 1 : y; */
+}
+
+// spherical mercator to longitude/latitude
+function xLng(x, crs) {
+    if (!crs || crs === 'EPSG:3857') {
+        return (x - 0.5) * 360;
+    } else {
+        return (x - 0.5) * 360;
+    }
+    // return (x - 0.5) * 360;
+}
+function yLat(y, crs) {
+    if (!crs || crs === 'EPSG:3857') {
+        var y2 = (180 - y * 360) * Math.PI / 180;
+        return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+    } else {
+        return 90 - (y * 360);
+    }
+
+    // const y2 = (180 - y * 360) * Math.PI / 180;
+    // return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+}
+
+function extend(dest, src) {
+    for (var id in src) { dest[id] = src[id]; }
+    return dest;
+}
+
+function getX(p) {
+    return p.x;
+}
+function getY(p) {
+    return p.y;
+}
+
+return Supercluster;
+
+})));

package/dist/supercluster.min.js

@@ -0,0 +1 @@
+!function(t,o){"object"==typeof exports&&"undefined"!=typeof module?module.exports=o():"function"==typeof define&&define.amd?define(o):(t=t||self).Supercluster=o()}(this,(function(){"use strict";function t(e,n,r,i,s,a){if(!(s-i<=r)){var p=i+s>>1;!function t(e,n,r,i,s,a){for(;s>i;){if(s-i>600){var p=s-i+1,h=r-i+1,u=Math.log(p),f=.5*Math.exp(2*u/3),d=.5*Math.sqrt(u*f*(p-f)/p)*(h-p/2<0?-1:1),l=Math.max(i,Math.floor(r-h*f/p+d)),c=Math.min(s,Math.floor(r+(p-h)*f/p+d));t(e,n,r,l,c,a)}var m=n[2*r+a],v=i,g=s;for(o(e,n,i,r),n[2*s+a]>m&&o(e,n,i,s);v<g;){for(o(e,n,v,g),v++,g--;n[2*v+a]<m;)v++;for(;n[2*g+a]>m;)g--}n[2*i+a]===m?o(e,n,i,g):(g++,o(e,n,g,s)),g<=r&&(i=g+1),r<=g&&(s=g-1)}}(e,n,p,i,s,a%2),t(e,n,r,i,p-1,a+1),t(e,n,r,p+1,s,a+1)}}function o(t,o,n,r){e(t,n,r),e(o,2*n,2*r),e(o,2*n+1,2*r+1)}function e(t,o,e){var n=t[o];t[o]=t[e],t[e]=n}function n(t,o,e,n){var r=t-e,i=o-n;return r*r+i*i}var r=function(t){return t[0]},i=function(t){return t[1]},s=function(o,e,n,s,a){void 0===e&&(e=r),void 0===n&&(n=i),void 0===s&&(s=64),void 0===a&&(a=Float64Array),this.nodeSize=s,this.points=o;for(var p=o.length<65536?Uint16Array:Uint32Array,h=this.ids=new p(o.length),u=this.coords=new a(2*o.length),f=0;f<o.length;f++)h[f]=f,u[2*f]=e(o[f]),u[2*f+1]=n(o[f]);t(h,u,s,0,h.length-1,0)};s.prototype.range=function(t,o,e,n){return function(t,o,e,n,r,i,s){for(var a,p,h=[0,t.length-1,0],u=[];h.length;){var f=h.pop(),d=h.pop(),l=h.pop();if(d-l<=s)for(var c=l;c<=d;c++)a=o[2*c],p=o[2*c+1],a>=e&&a<=r&&p>=n&&p<=i&&u.push(t[c]);else{var m=Math.floor((l+d)/2);a=o[2*m],p=o[2*m+1],a>=e&&a<=r&&p>=n&&p<=i&&u.push(t[m]);var v=(f+1)%2;(0===f?e<=a:n<=p)&&(h.push(l),h.push(m-1),h.push(v)),(0===f?r>=a:i>=p)&&(h.push(m+1),h.push(d),h.push(v))}}return u}(this.ids,this.coords,t,o,e,n,this.nodeSize)},s.prototype.within=function(t,o,e){return function(t,o,e,r,i,s){for(var a=[0,t.length-1,0],p=[],h=i*i;a.length;){var u=a.pop(),f=a.pop(),d=a.pop();if(f-d<=s)for(var l=d;l<=f;l++)n(o[2*l],o[2*l+1],e,r)<=h&&p.push(t[l]);else{var c=Math.floor((d+f)/2),m=o[2*c],v=o[2*c+1];n(m,v,e,r)<=h&&p.push(t[c]);var g=(u+1)%2;(0===u?e-i<=m:r-i<=v)&&(a.push(d),a.push(c-1),a.push(g)),(0===u?e+i>=m:r+i>=v)&&(a.push(c+1),a.push(f),a.push(g))}}return p}(this.ids,this.coords,t,o,e,this.nodeSize)};var a={crs:"EPSG:3857",minZoom:0,maxZoom:16,minPoints:2,radius:40,extent:512,nodeSize:64,log:!1,generateId:!1,reduce:null,map:function(t){return t}},p=function(t){this.options=g(Object.create(a),t),this.trees=new Array(this.options.maxZoom+1)};function h(t,o,e,n,r){return{x:t,y:o,zoom:1/0,id:e,parentId:-1,numPoints:n,properties:r}}function u(t,o,e){var n=t.geometry.coordinates,r=n[0],i=n[1];return{x:l(r,e),y:c(i,e),zoom:1/0,index:o,parentId:-1}}function f(t,o){return{type:"Feature",id:t.id,properties:d(t),geometry:{type:"Point",coordinates:[m(t.x,o),v(t.y,o)]}}}function d(t){var o=t.numPoints,e=o>=1e4?Math.round(o/1e3)+"k":o>=1e3?Math.round(o/100)/10+"k":o;return g(g({},t.properties),{cluster:!0,cluster_id:t.id,point_count:o,point_count_abbreviated:e})}function l(t,o){return t/360+.5}function c(t,o){var e;if(o&&"EPSG:3857"!==o)e=(90-t)/360;else{var n=Math.sin(t*Math.PI/180);e=.5-.25*Math.log((1+n)/(1-n))/Math.PI}return e<0?0:e>1?1:e}function m(t,o){return 360*(t-.5)}function v(t,o){if(o&&"EPSG:3857"!==o)return 90-360*t;var e=(180-360*t)*Math.PI/180;return 360*Math.atan(Math.exp(e))/Math.PI-90}function g(t,o){for(var e in o)t[e]=o[e];return t}function y(t){return t.x}function x(t){return t.y}return p.prototype.load=function(t){var o=this.options,e=o.log,n=o.minZoom,r=o.maxZoom,i=o.nodeSize,a=o.crs;e&&console.time("total time");var p="prepare "+t.length+" points";e&&console.time(p),this.points=t;for(var h=[],f=0;f<t.length;f++)t[f].geometry&&h.push(u(t[f],f,a));this.trees[r+1]=new s(h,y,x,i,Float32Array),e&&console.timeEnd(p);for(var d=r;d>=n;d--){var l=+Date.now();h=this._cluster(h,d),this.trees[d]=new s(h,y,x,i,Float32Array),e&&console.log("z%d: %d clusters in %dms",d,h.length,+Date.now()-l)}return e&&console.timeEnd("total time"),this},p.prototype.getClusters=function(t,o){var e=this.crs,n=((t[0]+180)%360+360)%360-180,r=Math.max(-90,Math.min(90,t[1])),i=180===t[2]?180:((t[2]+180)%360+360)%360-180,s=Math.max(-90,Math.min(90,t[3]));if(t[2]-t[0]>=360)n=-180,i=180;else if(n>i){var a=this.getClusters([n,r,180,s],o),p=this.getClusters([-180,r,i,s],o);return a.concat(p)}for(var h=this.trees[this._limitZoom(o)],u=[],d=0,m=h.range(l(n,e),c(s,e),l(i,e),c(r,e));d<m.length;d+=1){var v=m[d],g=h.points[v];u.push(g.numPoints?f(g,e):this.points[g.index])}return u},p.prototype.getChildren=function(t){var o=this.crs,e=this._getOriginId(t),n=this._getOriginZoom(t),r="No cluster with the specified id.",i=this.trees[n];if(!i)throw new Error(r);var s=i.points[e];if(!s)throw new Error(r);for(var a=this.options.radius/(this.options.extent*Math.pow(2,n-1)),p=[],h=0,u=i.within(s.x,s.y,a);h<u.length;h+=1){var d=u[h],l=i.points[d];l.parentId===t&&p.push(l.numPoints?f(l,o):this.points[l.index])}if(0===p.length)throw new Error(r);return p},p.prototype.getLeaves=function(t,o,e){o=o||10,e=e||0;var n=[];return this._appendLeaves(n,t,o,e,0),n},p.prototype.getTile=function(t,o,e){var n=this.trees[this._limitZoom(t)],r=Math.pow(2,t),i=this.options,s=i.extent,a=i.radius/s,p=(e-a)/r,h=(e+1+a)/r,u={features:[]};return this._addTileFeatures(n.range((o-a)/r,p,(o+1+a)/r,h),n.points,o,e,r,u),0===o&&this._addTileFeatures(n.range(1-a/r,p,1,h),n.points,r,e,r,u),o===r-1&&this._addTileFeatures(n.range(0,p,a/r,h),n.points,-1,e,r,u),u.features.length?u:null},p.prototype.getClusterExpansionZoom=function(t){for(var o=this._getOriginZoom(t)-1;o<=this.options.maxZoom;){var e=this.getChildren(t);if(o++,1!==e.length)break;t=e[0].properties.cluster_id}return o},p.prototype._appendLeaves=function(t,o,e,n,r){for(var i=0,s=this.getChildren(o);i<s.length;i+=1){var a=s[i],p=a.properties;if(p&&p.cluster?r+p.point_count<=n?r+=p.point_count:r=this._appendLeaves(t,p.cluster_id,e,n,r):r<n?r++:t.push(a),t.length===e)break}return r},p.prototype._addTileFeatures=function(t,o,e,n,r,i){for(var s=0,a=t;s<a.length;s+=1){var p=o[a[s]],h=p.numPoints,u={type:1,geometry:[[Math.round(this.options.extent*(p.x*r-e)),Math.round(this.options.extent*(p.y*r-n))]],tags:h?d(p):this.points[p.index].properties},f=void 0;h?f=p.id:this.options.generateId?f=p.index:this.points[p.index].id&&(f=this.points[p.index].id),void 0!==f&&(u.id=f),i.features.push(u)}},p.prototype._limitZoom=function(t){return Math.max(this.options.minZoom,Math.min(+t,this.options.maxZoom+1))},p.prototype._cluster=function(t,o){for(var e=[],n=this.options,r=n.radius,i=n.extent,s=n.reduce,a=n.minPoints,p=r/(i*Math.pow(2,o)),u=0;u<t.length;u++){var f=t[u];if(!(f.zoom<=o)){f.zoom=o;for(var d=this.trees[o+1],l=d.within(f.x,f.y,p),c=f.numPoints||1,m=c,v=0,g=l;v<g.length;v+=1){var y=g[v],x=d.points[y];x.zoom>o&&(m+=x.numPoints||1)}if(m>=a){for(var M=f.x*c,_=f.y*c,w=s&&c>1?this._map(f,!0):null,P=(u<<5)+(o+1)+this.points.length,z=0,Z=l;z<Z.length;z+=1){var I=Z[z],E=d.points[I];if(!(E.zoom<=o)){E.zoom=o;var S=E.numPoints||1;M+=E.x*S,_+=E.y*S,E.parentId=P,s&&(w||(w=this._map(f,!0)),s(w,this._map(E)))}}f.parentId=P,e.push(h(M/m,_/m,P,m,w))}else if(e.push(f),m>1)for(var F=0,C=l;F<C.length;F+=1){var b=C[F],A=d.points[b];A.zoom<=o||(A.zoom=o,e.push(A))}}}return e},p.prototype._getOriginId=function(t){return t-this.points.length>>5},p.prototype._getOriginZoom=function(t){return(t-this.points.length)%32},p.prototype._map=function(t,o){if(t.numPoints)return o?g({},t.properties):t.properties;var e=this.points[t.index].properties,n=this.options.map(e);return o&&n===e?g({},n):n},p}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapgis/supercluster",
-"version":"16.6.0",
+"version":"17.0.0",
   "description": "A very fast geospatial point clustering library.",
   "main": "dist/supercluster.js",
   "module": "index.js",