@piwitests/server 0.25.0 → 0.26.0

package/.output/server/node_modules/@unovis/ts/components/topojson-map/index.js

@@ -1,1294 +0,0 @@
-import { select } from 'd3-selection';
-import { zoomIdentity, zoom } from 'd3-zoom';
-import { timeout } from 'd3-timer';
-import { easeCubicInOut } from 'd3-ease';
-import { geoPath } from 'd3-geo';
-import { color } from 'd3-color';
-import { packSiblings } from 'd3-hierarchy';
-import { feature } from 'topojson-client';
-import { ComponentCore } from '../../core/component/index.js';
-import { MapGraphDataModel } from '../../data-models/map-graph.js';
-import { getNumber, isNumber, getString, clamp } from '../../utils/data.js';
-import { smartTransition } from '../../utils/d3.js';
-import { getColor, hexToBrightness } from '../../utils/color.js';
-import { isStringCSSVariable, getCSSVariableValue } from '../../utils/misc.js';
-import { trimStringMiddle } from '../../utils/text.js';
-import { MapProjection, TopoJSONMapPointShape, MapPointLabelPosition } from './types.js';
-import { TopoJSONMapDefaultConfig } from './config.js';
-import { calculateClusterIndex, getClusterRadius, getLonLat, arc, getDonutData, getPointPathData, getClustersAndPoints, geoJsonPointToScreenPoint, collideAreaLabels, collidePointBottomLabels, getNextZoomLevelOnClusterClick, getPointRadius } from './utils.js';
-import { updateDonut } from './modules/donut.js';
-import { renderBackground } from './modules/background.js';
-import { updateSelectionRing } from './modules/selectionRing.js';
-import { initFlowFeatures, updateFlowParticles } from './modules/flow.js';
-import * as style from './style.js';
-import { background, features, areaLabel, links, clusterBackground, flowParticles, points, pointSelectionRing, pointSelection, sourcePoints, feature as feature$1, variables, clusterBackgroundCircle, link, point, pointShape, clusterDonut, pointDonut, pointPathRing, pointLabel, pointBottomLabel, sourcePoint, flowParticle } from './style.js';
-
-// Supercluster expects zoom levels 0-22 (like map tiles). zoomExtent[1] is a scale factor
-// for the map, so we cap the cluster maxZoom to avoid excessive quadtree depth and wrong
-// packing/expansion behavior when zoomExtent has large values (e.g. 1000).
-const SUPERCLUSTER_MAX_ZOOM = 22;
-class TopoJSONMap extends ComponentCore {
-    constructor(config, data) {
-        super();
-        this._defaultConfig = TopoJSONMapDefaultConfig;
-        this.config = this._defaultConfig;
-        this.datamodel = new MapGraphDataModel();
-        this._firstRender = true;
-        this._isResizing = false;
-        this._initialScale = undefined;
-        this._currentZoomLevel = undefined;
-        this._transform = zoomIdentity;
-        this._path = geoPath();
-        this._isZooming = false;
-        this._clusterIndex = null;
-        this._expandedCluster = null;
-        this._collapsedCluster = null;
-        this._collapsedClusterPointIds = null;
-        this._prevZoomToLocation = undefined;
-        this._eventInitiatedByComponent = false;
-        this._zoomBehavior = zoom();
-        this._backgroundRect = this.g.append('rect').attr('class', background);
-        this._featuresGroup = this.g.append('g').attr('class', features);
-        this._areaLabelsGroup = this.g.append('g').attr('class', areaLabel);
-        this._linksGroup = this.g.append('g').attr('class', links);
-        this._clusterBackgroundGroup = this.g.append('g').attr('class', clusterBackground);
-        this._flowParticlesGroup = this.g.append('g').attr('class', flowParticles);
-        // Points after links + flow groups so map nodes paint above link arcs and flow particles
-        this._pointsGroup = this.g.append('g').attr('class', points);
-        this._pointSelectionRing = this._pointsGroup.append('g').attr('class', pointSelectionRing)
-            .call(sel => sel.append('path').attr('class', pointSelection));
-        this._sourcePointsGroup = this.g.append('g').attr('class', sourcePoints);
-        this._selectedPoint = null;
-        this._flowParticles = [];
-        this._sourcePoints = [];
-        this._animationId = null;
-        this.events = {
-            [TopoJSONMap.selectors.point]: {},
-            [TopoJSONMap.selectors.feature]: {},
-        };
-        this._zoomBehavior
-            .on('zoom', this._onZoom.bind(this))
-            .on('end', this._onZoomEnd.bind(this));
-        if (config)
-            this.setConfig(config);
-        if (data)
-            this.setData(data);
-        this.g.append('defs')
-            .append('filter')
-            .attr('id', 'heatmapFilter')
-            .html(`
-        <feGaussianBlur in="SourceGraphic" stdDeviation="${this.config.heatmapModeBlurStdDeviation}" color-interpolation-filters="sRGB" result="blur"></feGaussianBlur>
-        <feColorMatrix class="blurValues" in="blur" mode="matrix" values="1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 20 -4"></feColorMatrix>
-      `);
-    }
-    setData(data) {
-        var _a;
-        const { config } = this;
-        this.datamodel.pointId = config.pointId;
-        this.datamodel.linkSource = config.linkSource;
-        this.datamodel.linkTarget = config.linkTarget;
-        this.datamodel.data = data;
-        // Reset expanded cluster when data changes
-        this._resetExpandedCluster();
-        // Initialize clustering if enabled
-        if (config.clustering && ((_a = data.points) === null || _a === void 0 ? void 0 : _a.length)) {
-            const dataValid = data.points.filter(d => {
-                const lat = getNumber(d, config.latitude);
-                const lon = getNumber(d, config.longitude);
-                return isNumber(lat) && isNumber(lon);
-            });
-            const zoomExtent = this.config.zoomExtent;
-            const maxClusterZoomLevel = Array.isArray(zoomExtent) ? Math.min(zoomExtent[1], SUPERCLUSTER_MAX_ZOOM) : 16;
-            this._clusterIndex = calculateClusterIndex(dataValid, this.config, maxClusterZoomLevel);
-        }
-        else {
-            this._clusterIndex = null;
-        }
-        // If there was a data change and mapFitToPoints is enabled, we will need to re-fit the map
-        this._firstRender = this._firstRender || config.mapFitToPoints;
-    }
-    setConfig(config) {
-        var _a;
-        super.setConfig(config);
-        // Setting the default here instead of defaultConfig to prevent mutation from other TopoJSONMap instances
-        const newProjection = (_a = this.config.projection) !== null && _a !== void 0 ? _a : MapProjection.Kavrayskiy7();
-        if (this._projection) {
-            newProjection.scale(this._projection.scale()).translate(this._projection.translate());
-        }
-        this._projection = newProjection;
-    }
-    _render(customDuration) {
-        const { config } = this;
-        const duration = isNumber(customDuration) ? customDuration : config.duration;
-        this._renderBackground();
-        this._renderMap(duration);
-        this._renderAreaLabels(duration);
-        this._renderGroups(duration);
-        this._renderLinks(duration);
-        this._renderClusterBackground(duration);
-        this._renderPoints(duration);
-        // Flow features
-        if (config.enableFlowAnimation) {
-            this._initFlowFeatures();
-            this._renderSourcePoints(duration);
-            this._renderFlowParticles(duration);
-            this._startFlowAnimation();
-        }
-        else {
-            this._stopFlowAnimation();
-        }
-        // When animation is running we need to temporary disable zoom behaviour
-        if (duration && !config.disableZoom) {
-            this.g.on('.zoom', null);
-            timeout(() => {
-                this.g.call(this._zoomBehavior);
-            }, duration);
-        }
-        // When zoom behaviour is active we assign the `draggable` class to show the grabbing cursor
-        this.g.classed('draggable', !config.disableZoom);
-        this._firstRender = false;
-        // Apply zoomToLocation if it changed
-        if (config.zoomToLocation) {
-            const hasChanged = !this._prevZoomToLocation ||
-                this._prevZoomToLocation.coordinates[0] !== config.zoomToLocation.coordinates[0] ||
-                this._prevZoomToLocation.coordinates[1] !== config.zoomToLocation.coordinates[1] ||
-                this._prevZoomToLocation.zoomLevel !== config.zoomToLocation.zoomLevel ||
-                this._prevZoomToLocation.expandCluster !== config.zoomToLocation.expandCluster;
-            if (hasChanged) {
-                this._prevZoomToLocation = Object.assign({}, config.zoomToLocation);
-                // If expandCluster is true, find and expand the cluster at/near the coordinates
-                if (config.zoomToLocation.expandCluster) {
-                    const cluster = this._findClusterAtCoordinates(config.zoomToLocation.coordinates);
-                    if (cluster) {
-                        this._expandCluster(cluster);
-                    }
-                }
-                this._zoomToLocation(config.zoomToLocation.coordinates, config.zoomToLocation.zoomLevel);
-            }
-        }
-        else {
-            this._prevZoomToLocation = undefined;
-        }
-        // Run collision detection after initial render
-        if (!this._isZooming) {
-            this._runCollisionDetection();
-        }
-    }
-    _renderBackground() {
-        renderBackground(this._backgroundRect, this.bleed.left, this.bleed.top, () => this._collapseExpandedCluster());
-    }
-    _renderGroups(duration) {
-        const transformString = this._transform.toString();
-        smartTransition(this._featuresGroup, duration)
-            .attr('transform', transformString)
-            .attr('stroke-width', 1 / this._currentZoomLevel);
-        smartTransition(this._areaLabelsGroup, duration)
-            .attr('transform', transformString);
-        smartTransition(this._linksGroup, duration)
-            .attr('transform', transformString);
-        smartTransition(this._clusterBackgroundGroup, duration)
-            .attr('transform', transformString);
-        smartTransition(this._pointsGroup, duration)
-            .attr('transform', transformString);
-        smartTransition(this._sourcePointsGroup, duration)
-            .attr('transform', transformString);
-        smartTransition(this._flowParticlesGroup, duration)
-            .attr('transform', transformString);
-    }
-    _renderMap(duration) {
-        var _a, _b, _c, _d, _e;
-        const { bleed, config, datamodel } = this;
-        this.g.attr('transform', `translate(${bleed.left}, ${bleed.top})`);
-        const mapData = config.topojson;
-        const featureName = config.mapFeatureName;
-        const featureObject = (_a = mapData === null || mapData === void 0 ? void 0 : mapData.objects) === null || _a === void 0 ? void 0 : _a[featureName];
-        if (!featureObject)
-            return;
-        this._featureCollection = feature(mapData, featureObject);
-        const featureData = ((_c = (_b = this._featureCollection) === null || _b === void 0 ? void 0 : _b.features) !== null && _c !== void 0 ? _c : []);
-        if (this._firstRender) {
-            // Rendering the map for the first time.
-            this._projection.fitExtent([[0, 0], [this._width, this._height]], this._featureCollection);
-            if (config.mapFitToPoints) {
-                // Re-fit projection to points instead of full topojson
-                this._fitToPoints();
-            }
-            // After initial fit (to features or points), treat the current projection
-            // scale as the baseline for zoom level 1.
-            this._initialScale = this._projection.scale();
-            this._center = this._projection.translate();
-            const zoomExtent = config.zoomExtent;
-            this._zoomBehavior.scaleExtent([zoomExtent[0] * this._initialScale, zoomExtent[1] * this._initialScale]);
-            this._currentZoomLevel = config.zoomFactor || 1;
-            (_e = (_d = this.g.node()) === null || _d === void 0 ? void 0 : _d.parentElement) === null || _e === void 0 ? void 0 : _e.style.setProperty('--vis-map-current-zoom-level', String(this._currentZoomLevel));
-            if (!config.disableZoom) {
-                this.g.call(this._zoomBehavior);
-                this._applyZoom();
-            }
-            // Initialize transform for first render after applyZoom
-            const scale = this._currentZoomLevel;
-            const center = this._projection.translate();
-            this._transform = zoomIdentity
-                .translate(this._center[0] - center[0] * scale, this._center[1] - center[1] * scale)
-                .scale(scale);
-            this._prevWidth = this._width;
-            this._prevHeight = this._height;
-        }
-        if (this._prevWidth !== this._width || this._prevHeight !== this._height) {
-            this._onResize();
-        }
-        this._path.projection(this._projection);
-        // Merge passed area data and map feature data
-        const areaData = datamodel.areas;
-        areaData.forEach(a => {
-            const feature = featureData.find(f => f.id.toString() === getString(a, config.areaId).toString());
-            if (feature)
-                feature.data = a;
-            else if (this._firstRender)
-                console.warn(`Can't find feature by area code ${getString(a, config.areaId)}`);
-        });
-        const features = this._featuresGroup
-            .selectAll(`.${feature$1}`)
-            .data(featureData);
-        const featuresEnter = features.enter().append('path').attr('class', feature$1);
-        const featuresMerged = featuresEnter.merge(features);
-        // Animate geometry changes, but apply fill immediately to avoid "delay then jump"
-        smartTransition(featuresMerged, duration)
-            .attr('d', this._path)
-            .style('cursor', d => d.data ? getString(d.data, config.areaCursor) : null);
-        // Set fill directly so color updates are instantaneous instead of snapping at the end of a transition
-        featuresMerged.style('fill', (d, i) => d.data ? getColor(d.data, config.areaColor, i) : null);
-        // Add click handler to collapse expanded cluster when clicking on map features
-        featuresMerged.on('click', () => {
-            this._collapseExpandedCluster();
-        });
-        features.exit().remove();
-    }
-    _renderAreaLabels(duration) {
-        var _a, _b;
-        const { config } = this;
-        // Early return if no area label configuration
-        if (!config.areaLabel) {
-            this._areaLabelsGroup.selectAll('*').remove();
-            return;
-        }
-        const featureData = ((_b = (_a = this._featureCollection) === null || _a === void 0 ? void 0 : _a.features) !== null && _b !== void 0 ? _b : []);
-        // Prepare candidate labels with optimized filtering and calculations
-        const candidateLabels = featureData
-            .map(feature => {
-            var _a;
-            // Use area data if present, otherwise fall back to GeoJSON properties
-            const areaDatum = feature.data || feature.properties;
-            const labelText = areaDatum ? getString(areaDatum, config.areaLabel) : null;
-            if (!labelText)
-                return null;
-            const centroid = this._path.centroid(feature);
-            // Skip if centroid is invalid (e.g., for very small or complex shapes)
-            if (!centroid || centroid.some(coord => !isFinite(coord)))
-                return null;
-            const bounds = this._path.bounds(feature);
-            const area = (bounds[1][0] - bounds[0][0]) * (bounds[1][1] - bounds[0][1]);
-            return {
-                feature,
-                centroid,
-                area,
-                labelText,
-                id: feature.data ? getString(feature.data, config.areaId) : (_a = feature.id) === null || _a === void 0 ? void 0 : _a.toString(),
-            };
-        })
-            .filter(Boolean) // Remove null entries
-            .sort((a, b) => b.area - a.area); // Prioritize larger areas
-        // D3 data binding with improved key function
-        const labels = this._areaLabelsGroup
-            .selectAll(`.${areaLabel}`)
-            .data(candidateLabels, d => d.id || '');
-        // Handle entering labels
-        const labelsEnter = labels.enter()
-            .append('text')
-            .attr('class', areaLabel)
-            .attr('transform', d => `translate(${d.centroid[0]},${d.centroid[1]})`)
-            .style('opacity', 0)
-            .style('pointer-events', 'none');
-        // Update all labels (enter + update)
-        const labelsMerged = labelsEnter.merge(labels);
-        labelsMerged
-            .text(d => d.labelText)
-            .attr('transform', d => `translate(${d.centroid[0]},${d.centroid[1]})`)
-            .style('font-size', `calc(var(${variables.mapPointLabelFontSize}) / ${this._currentZoomLevel})`)
-            .style('text-anchor', 'middle')
-            .style('dominant-baseline', 'middle');
-        // Handle exiting labels
-        smartTransition(labels.exit(), duration)
-            .style('opacity', 0)
-            .remove();
-        // Only update opacity after zoom completes
-        if (!this._isZooming) {
-            smartTransition(labelsMerged, duration)
-                .style('opacity', 1);
-        }
-    }
-    _renderClusterBackground(duration) {
-        const { config } = this;
-        const currentZoomLevel = this._currentZoomLevel || 1;
-        // Always remove existing background circles first
-        this._clusterBackgroundGroup.selectAll('circle').remove();
-        if (this._expandedCluster && config.clusterBackground) {
-            const cluster = this._expandedCluster.cluster;
-            const pos = this._projection(cluster.geometry.coordinates);
-            const backgroundRadius = getClusterRadius(this._expandedCluster);
-            // Divide by zoom level since the group transform will scale it back up
-            const adjustedRadius = backgroundRadius / currentZoomLevel;
-            this._clusterBackgroundGroup
-                .append('circle')
-                .attr('class', clusterBackgroundCircle)
-                .attr('cx', pos[0])
-                .attr('cy', pos[1])
-                .attr('r', 0)
-                .style('fill', `var(${variables.mapClusterExpandedBackgroundFillColor})`)
-                .style('opacity', 0)
-                .style('cursor', 'pointer')
-                .on('click', () => {
-                this._collapseExpandedCluster();
-            })
-                .transition()
-                .duration(duration)
-                .attr('r', adjustedRadius)
-                .style('opacity', 0.7);
-        }
-    }
-    _renderLinks(duration) {
-        const { config, datamodel } = this;
-        const links = datamodel.links;
-        const edges = this._linksGroup
-            .selectAll(`.${link}`)
-            .data(links, (d, i) => getString(d, config.linkId, i));
-        const edgesEnter = edges.enter().append('path').attr('class', link)
-            .style('stroke-width', 0);
-        smartTransition(edgesEnter.merge(edges), duration)
-            .attr('d', link => {
-            const source = this._projection(getLonLat(link.source, config.longitude, config.latitude));
-            const target = this._projection(getLonLat(link.target, config.longitude, config.latitude));
-            return arc(source, target);
-        })
-            .style('stroke-width', link => getNumber(link, config.linkWidth) / this._currentZoomLevel)
-            .style('cursor', link => getString(link, config.linkCursor))
-            .style('stroke', (link, i) => getColor(link, config.linkColor, i));
-        edges.exit().remove();
-    }
-    _shouldFilterPointOrCluster(point, pointIdsToFilter) {
-        const { config } = this;
-        // If it's a cluster (potential subcluster), check if any of its leaves should be filtered
-        if (point.properties.cluster) {
-            const clusterId = point.properties.clusterId;
-            const clusterLeaves = this._clusterIndex.getLeaves(clusterId, Infinity);
-            // Filter out this subcluster if any of its leaves are in the filter set
-            return clusterLeaves.some((leaf) => pointIdsToFilter.has(getString(leaf.properties, config.pointId)));
-        }
-        // For individual points, filter if they're in the filter set
-        const pointId = getString(point.properties, config.pointId);
-        return pointIdsToFilter.has(pointId);
-    }
-    _getPointData() {
-        const { config, datamodel } = this;
-        if (!config.clustering || !this._clusterIndex) {
-            // Return regular points when clustering is disabled
-            return datamodel.points.map((d, i) => {
-                const pos = this._projection(getLonLat(d, config.longitude, config.latitude));
-                const radius = getNumber(d, config.pointRadius);
-                const shape = getString(d, config.pointShape) || TopoJSONMapPointShape.Circle;
-                const donutData = getDonutData(d, config.colorMap);
-                const pointColor = getColor(d, config.pointColor, i);
-                return {
-                    geometry: { type: 'Point', coordinates: getLonLat(d, config.longitude, config.latitude) },
-                    bbox: { x1: pos[0] - radius, y1: pos[1] - radius, x2: pos[0] + radius, y2: pos[1] + radius },
-                    radius,
-                    path: getPointPathData({ x: 0, y: 0 }, radius, shape),
-                    color: pointColor,
-                    id: getString(d, config.pointId, i),
-                    properties: d,
-                    donutData,
-                    isCluster: false,
-                    _zIndex: 0,
-                };
-            });
-        }
-        // Get bounds for clustering - [westLng, southLat, eastLng, northLat]
-        // For now, use full world bounds since calculating viewport bounds with zoom transforms is complex
-        const bounds = [-180, -90, 180, 90];
-        // Use map zoom level directly for Supercluster, capped at SUPERCLUSTER_MAX_ZOOM.
-        // Supercluster expects zoom 0-22; beyond that, all points are unclustered anyway.
-        const mapZoom = this._currentZoomLevel || 1;
-        const zoom = Math.max(0, Math.min(Math.round(mapZoom), SUPERCLUSTER_MAX_ZOOM));
-        let geoJsonPoints = getClustersAndPoints(this._clusterIndex, bounds, zoom);
-        // Handle expanded cluster points - replace the expanded cluster with individual points
-        if (this._expandedCluster) {
-            const expandedClusterId = this._expandedCluster.cluster.properties.clusterId;
-            // Remove the expanded cluster if it still exists at this zoom level
-            geoJsonPoints = geoJsonPoints.filter((c) => {
-                const props = c.properties;
-                const isExpandedCluster = props.cluster && props.clusterId === expandedClusterId;
-                return !isExpandedCluster;
-            });
-            // Remove any individual points and subclusters that are part of the expanded cluster to avoid duplicates
-            const expandedPointIds = new Set(this._expandedCluster.points.map(p => p.id.toString()));
-            geoJsonPoints = geoJsonPoints.filter(c => !this._shouldFilterPointOrCluster(geoJsonPointToScreenPoint(c, 0, this._projection, this.config, this._currentZoomLevel || 1), expandedPointIds));
-            // Add points from the expanded cluster
-            geoJsonPoints = geoJsonPoints.concat(this._expandedCluster.points);
-        }
-        if (this._collapsedCluster) {
-            // When collapsed, restore the original cluster point instead of relying on clustering algorithm
-            const collapsedClusterId = this._collapsedCluster.properties.clusterId;
-            // Check if the clustering algorithm has recreated a similar cluster at this zoom level
-            const hasNaturalCluster = geoJsonPoints.some(c => {
-                const props = c.properties;
-                return props.cluster && props.clusterId === collapsedClusterId;
-            });
-            if (hasNaturalCluster) {
-                // Natural cluster exists, we can safely clear the collapsed cluster
-                this._collapsedCluster = null;
-                this._collapsedClusterPointIds = null;
-            }
-            else {
-                // Remove any individual points and subclusters that were part of the collapsed cluster
-                geoJsonPoints = geoJsonPoints.filter(c => !this._shouldFilterPointOrCluster(geoJsonPointToScreenPoint(c, 0, this._projection, this.config, this._currentZoomLevel || 1), this._collapsedClusterPointIds));
-                // Add the original cluster back
-                geoJsonPoints.push(this._collapsedCluster);
-            }
-        }
-        return geoJsonPoints.map((geoPoint, i) => geoJsonPointToScreenPoint(geoPoint, i, this._projection, this.config, this._currentZoomLevel || 1));
-    }
-    _renderPoints(duration) {
-        const { config } = this;
-        const pointData = this._getPointData();
-        const currentZoomLevel = this._currentZoomLevel || 1;
-        // Set z-index for expanded cluster points to ensure proper layering
-        if (this._expandedCluster && config.clusterBackground) {
-            pointData.forEach((d) => {
-                const expandedPoint = d;
-                expandedPoint._zIndex = expandedPoint.expandedClusterPoint ? 2 : 0;
-            });
-        }
-        const points = this._pointsGroup
-            .selectAll(`.${point}`)
-            .data(pointData, (d, i) => { var _a, _b; return (_b = (_a = d.id) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : `point-${i}`; });
-        // Enter
-        const pointsEnter = points.enter().append('g').attr('class', point)
-            .attr('transform', d => {
-            var _a, _b;
-            const pos = this._projection(d.geometry.coordinates);
-            const expandedPoint = d;
-            // Divide by zoom level to compensate for the group's zoom transform
-            const dx = ((_a = expandedPoint.dx) !== null && _a !== void 0 ? _a : 0) / currentZoomLevel;
-            const dy = ((_b = expandedPoint.dy) !== null && _b !== void 0 ? _b : 0) / currentZoomLevel;
-            return `translate(${pos[0] + dx},${pos[1] + dy})`;
-        })
-            .style('opacity', 1e-6);
-        // Main shape (circle, square, triangle) - always draw path; fill/stroke hide when donut shown (match leaflet)
-        pointsEnter.append('path')
-            .attr('class', pointShape)
-            .attr('d', d => {
-            const radius = d.radius / currentZoomLevel;
-            const shape = getString(d.properties, config.pointShape) || TopoJSONMapPointShape.Circle;
-            return getPointPathData({ x: 0, y: 0 }, radius, shape);
-        })
-            .style('fill', (d) => {
-            const shape = getString(d.properties, config.pointShape) || TopoJSONMapPointShape.Circle;
-            if (shape === TopoJSONMapPointShape.Ring)
-                return 'none';
-            return d.color;
-        })
-            .style('stroke', d => d.color)
-            .style('stroke-width', d => {
-            const shape = getString(d.properties, config.pointShape) || TopoJSONMapPointShape.Circle;
-            const isRing = shape === TopoJSONMapPointShape.Ring;
-            const baseStrokeWidth = isRing ? getNumber(d.properties, config.pointRingWidth) : getNumber(d.properties, config.pointStrokeWidth);
-            return baseStrokeWidth / currentZoomLevel;
-        });
-        // Donut group for color-map functionality
-        const donutGroup = pointsEnter.append('g')
-            .attr('class', d => d.isCluster ? clusterDonut : pointDonut)
-            .attr('data-point-id', (d, i) => getString(d.properties, config.pointId, i));
-        // Add background circle for clusters with donut data
-        donutGroup.each(function (d) {
-            if (d.isCluster && d.donutData.length > 0) {
-                select(this).append('circle')
-                    .attr('class', clusterBackground)
-                    .attr('r', 0);
-            }
-        });
-        // Ring overlay path for ring shape
-        pointsEnter.append('path')
-            .attr('class', pointPathRing)
-            .attr('d', 'M0,0')
-            .style('display', d => {
-            const shape = getString(d.properties, config.pointShape);
-            return shape === TopoJSONMapPointShape.Ring ? null : 'none';
-        });
-        // Center label (for cluster summary or point label)
-        pointsEnter.append('text')
-            .attr('class', pointLabel)
-            .attr('dy', '0.32em')
-            .style('opacity', 0);
-        pointsEnter.append('text').attr('class', pointBottomLabel)
-            .style('opacity', 0);
-        // Update
-        const pointsMerged = pointsEnter.merge(points);
-        smartTransition(pointsMerged, duration)
-            .attr('transform', d => {
-            var _a, _b;
-            const pos = this._projection(d.geometry.coordinates);
-            const expandedPoint = d;
-            // Divide by zoom level to compensate for the group's zoom transform
-            const dx = ((_a = expandedPoint.dx) !== null && _a !== void 0 ? _a : 0) / currentZoomLevel;
-            const dy = ((_b = expandedPoint.dy) !== null && _b !== void 0 ? _b : 0) / currentZoomLevel;
-            return `translate(${pos[0] + dx},${pos[1] + dy})`;
-        })
-            .style('cursor', d => {
-            var _a;
-            const expandedPoint = d;
-            // Expanded cluster points use default cursor (clicking them does nothing)
-            if (expandedPoint.expandedClusterPoint) {
-                return (_a = getString(expandedPoint.properties, config.pointCursor)) !== null && _a !== void 0 ? _a : 'default';
-            }
-            return d.isCluster ? 'pointer' : getString(d.properties, config.pointCursor);
-        })
-            .style('opacity', 1);
-        // Add click event handler for clusters
-        pointsMerged.on('click', (event, d) => {
-            this._onPointClick(d, event);
-        });
-        // Update donut charts and cluster backgrounds (match leaflet: radius 0 when shape is non-circular)
-        pointsMerged.selectAll(`.${pointDonut}, .${clusterDonut}`).each(function (d) {
-            const group = select(this);
-            const pointShape = getString(d.properties, config.pointShape);
-            const isRing = pointShape === TopoJSONMapPointShape.Ring;
-            const isCircular = (pointShape === TopoJSONMapPointShape.Circle) || isRing || d.isCluster || !pointShape;
-            // Update or create background circle for clusters
-            if (d.isCluster && d.donutData.length > 0) {
-                const radius = d.radius / currentZoomLevel;
-                const bgCircle = group.select(`.${clusterBackground}`);
-                if (bgCircle.empty()) {
-                    group.insert('circle', ':first-child')
-                        .attr('class', clusterBackground)
-                        .attr('r', radius);
-                }
-                else {
-                    bgCircle.attr('r', radius);
-                }
-            }
-            // Update donut/pie chart: pass radius 0 when non-circular so donut is not drawn (shape takes priority)
-            if (d.donutData.length > 0) {
-                const radius = (isCircular ? d.radius : 0) / currentZoomLevel;
-                const arcWidth = d.isCluster ? (2 / currentZoomLevel) : (isCircular ? d.radius / currentZoomLevel : 0);
-                const strokeWidth = 0.5 / currentZoomLevel;
-                updateDonut(group, d.donutData, radius, arcWidth, strokeWidth, 0.05);
-            }
-            else {
-                group.selectAll('*').remove();
-            }
-            // Update the class attribute based on whether it's a cluster
-            group.attr('class', d.isCluster ? clusterDonut : pointDonut);
-        });
-        // Update point shapes
-        smartTransition(pointsMerged.select(`.${pointShape}`), duration)
-            .attr('d', d => {
-            const radius = d.radius / currentZoomLevel;
-            const shape = getString(d.properties, config.pointShape) || TopoJSONMapPointShape.Circle;
-            return getPointPathData({ x: 0, y: 0 }, radius, shape);
-        })
-            .style('fill', d => {
-            const pointShape = getString(d.properties, config.pointShape);
-            const shape = pointShape || TopoJSONMapPointShape.Circle;
-            const isRing = shape === TopoJSONMapPointShape.Ring;
-            const hasDonut = d.donutData.length > 0;
-            const expandedPoint = d;
-            // For expanded cluster points, use the preserved cluster color
-            if (expandedPoint.expandedClusterPoint) {
-                return expandedPoint.clusterColor || expandedPoint.expandedClusterPoint.color;
-            }
-            if (isRing)
-                return 'none';
-            // Match leaflet: cluster with donut uses transparent background; otherwise path uses d.color (colorMap or pointColor)
-            if (hasDonut && d.isCluster)
-                return 'transparent';
-            return d.color;
-        })
-            .style('stroke', d => {
-            const expandedPoint = d;
-            // For expanded cluster points, use the preserved cluster color
-            if (expandedPoint.expandedClusterPoint) {
-                return expandedPoint.clusterColor || expandedPoint.expandedClusterPoint.color;
-            }
-            return d.color;
-        })
-            .style('stroke-width', d => {
-            const shape = getString(d.properties, config.pointShape) || TopoJSONMapPointShape.Circle;
-            const isRing = shape === TopoJSONMapPointShape.Ring;
-            const baseStrokeWidth = isRing ? getNumber(d.properties, config.pointRingWidth) : getNumber(d.properties, config.pointStrokeWidth);
-            return baseStrokeWidth / currentZoomLevel;
-        });
-        // Ring overlay update
-        smartTransition(pointsMerged.select(`.${pointPathRing}`), duration)
-            .attr('d', d => {
-            const shape = getString(d.properties, config.pointShape);
-            if (shape !== TopoJSONMapPointShape.Ring)
-                return '';
-            const radius = d.radius / currentZoomLevel;
-            return getPointPathData({ x: 0, y: 0 }, radius, TopoJSONMapPointShape.Circle);
-        })
-            .style('display', d => {
-            const shape = getString(d.properties, config.pointShape);
-            return shape === TopoJSONMapPointShape.Ring ? null : 'none';
-        });
-        const pointLabelsMerged = pointsMerged.select(`.${pointLabel}`);
-        pointLabelsMerged
-            .text(d => {
-            var _a, _b;
-            if (d.isCluster) {
-                return (_a = getString(d.properties, config.clusterLabel)) !== null && _a !== void 0 ? _a : '';
-            }
-            return (_b = getString(d.properties, config.pointLabel)) !== null && _b !== void 0 ? _b : '';
-        })
-            .style('font-size', d => {
-            if (config.pointLabelPosition === MapPointLabelPosition.Bottom) {
-                return `calc(var(${variables.mapPointLabelFontSize}) / ${currentZoomLevel})`;
-            }
-            const radius = d.isCluster
-                ? (d.radius / currentZoomLevel)
-                : getNumber(d.properties, config.pointRadius, 0) / currentZoomLevel;
-            const pointLabelText = d.isCluster
-                ? (getString(d.properties, config.clusterLabel) || '')
-                : (getString(d.properties, config.pointLabel) || '');
-            const textLength = pointLabelText.length;
-            // Use the same formula as Leaflet map for consistent font sizing
-            const fontSize = radius / Math.pow(textLength, 0.4);
-            // Match Leaflet: minimum is the calculated fontSize itself, max is 16
-            return clamp(fontSize, fontSize, 16);
-        })
-            .attr('y', d => {
-            // For points with pie/donut charts, always center the label
-            if (d.donutData.length > 0)
-                return null;
-            if (config.pointLabelPosition === MapPointLabelPosition.Center)
-                return null;
-            const radius = d.isCluster
-                ? (d.radius / currentZoomLevel)
-                : getNumber(d.properties, config.pointRadius, 0) / currentZoomLevel;
-            return radius;
-        })
-            .attr('dy', d => {
-            // For points with pie/donut charts, always use centered dy
-            if (d.donutData.length > 0)
-                return '0.32em';
-            return config.pointLabelPosition === MapPointLabelPosition.Center ? '0.32em' : '1em';
-        });
-        smartTransition(pointLabelsMerged, duration)
-            .style('fill', (d, i) => {
-            var _a;
-            if (d.donutData.length > 0) {
-                // Cluster background is white, so use dark text
-                return d.isCluster
-                    ? `var(${variables.mapPointLabelTextColorDark})`
-                    : `var(${variables.mapPointLabelTextColorLight})`;
-            }
-            else {
-                if (config.pointLabelColor) {
-                    const labelColor = getColor(d.properties, config.pointLabelColor, i);
-                    if (labelColor)
-                        return labelColor;
-                }
-                const pointColor = getColor(d.properties, config.pointColor, i);
-                const hex = (_a = color(isStringCSSVariable(pointColor) ? getCSSVariableValue(pointColor, this.element) : pointColor)) === null || _a === void 0 ? void 0 : _a.hex();
-                if (!hex)
-                    return null;
-                const brightness = hexToBrightness(hex);
-                return brightness > config.pointLabelTextBrightnessRatio
-                    ? `var(${variables.mapPointLabelTextColorDark})`
-                    : `var(${variables.mapPointLabelTextColorLight})`;
-            }
-        })
-            .style('opacity', 1)
-            .style('pointer-events', 'none')
-            .attr('visibility', d => {
-            // Show labels for clusters, individual points with pie charts, and when pointLabel is defined
-            const hasLabel = d.isCluster
-                ? !!getString(d.properties, config.clusterLabel)
-                : !!getString(d.properties, config.pointLabel);
-            return hasLabel ? null : 'hidden';
-        });
-        // Point & cluster bottom labels (hidden when point is inside expanded cluster)
-        const bottomLabelsMerged = pointsMerged.select(`.${pointBottomLabel}`);
-        bottomLabelsMerged
-            .attr('visibility', d => d.expandedClusterPoint ? 'hidden' : null)
-            .text(d => {
-            var _a, _b;
-            const bottomLabelText = d.isCluster
-                ? ((_a = getString(d.properties, config.clusterBottomLabel)) !== null && _a !== void 0 ? _a : '')
-                : ((_b = getString(d.properties, config.pointBottomLabel)) !== null && _b !== void 0 ? _b : '');
-            return trimStringMiddle(bottomLabelText, 15);
-        })
-            .attr('y', d => {
-            const radius = d.isCluster
-                ? (d.radius / this._currentZoomLevel)
-                : (getNumber(d.properties, config.pointRadius) / this._currentZoomLevel);
-            return radius + (10 / this._currentZoomLevel); // offset below the point/cluster, scaled with zoom
-        })
-            .attr('dy', '0.32em')
-            .style('font-size', `calc(var(${variables.mapPointBottomLabelFontSize}) / ${this._currentZoomLevel})`);
-        smartTransition(bottomLabelsMerged, duration)
-            .style('opacity', d => d.expandedClusterPoint ? 0 : 1);
-        // Sort elements by z-index to ensure expanded cluster points appear above everything else
-        if (this._expandedCluster && config.clusterBackground) {
-            this._pointsGroup
-                .selectAll(`.${point}`)
-                .sort((a, b) => a._zIndex - b._zIndex);
-        }
-        // Exit
-        points.exit().remove();
-        // Heatmap
-        this._pointsGroup.style('filter', (config.heatmapMode && this._currentZoomLevel < config.heatmapModeZoomLevelThreshold) ? 'url(#heatmapFilter)' : null);
-        this._pointsGroup.selectAll(`.${pointLabel}`).style('display', (config.heatmapMode && (this._currentZoomLevel < config.heatmapModeZoomLevelThreshold)) ? 'none' : null);
-        this._pointsGroup.selectAll(`.${pointBottomLabel}`).style('display', (config.heatmapMode && (this._currentZoomLevel < config.heatmapModeZoomLevelThreshold)) ? 'none' : null);
-        // Update selection ring
-        updateSelectionRing(this._pointSelectionRing, this._selectedPoint, pointData, this.config, this._projection, currentZoomLevel);
-        // Set up events and custom attributes for rendered points (match LeafletMap behavior)
-        this._setUpComponentEventsThrottled();
-        this._setCustomAttributesThrottled();
-    }
-    _fitToPoints(points, pad = 0.1) {
-        var _a, _b, _c, _d;
-        const { config, datamodel } = this;
-        const pointData = points || datamodel.points;
-        if (pointData.length === 0 && !((_b = (_a = datamodel.data) === null || _a === void 0 ? void 0 : _a.links) === null || _b === void 0 ? void 0 : _b.length))
-            return;
-        const coordinates = pointData.map(p => [
-            getNumber(p, d => getNumber(d, config.longitude)),
-            getNumber(p, d => getNumber(d, config.latitude)),
-        ]).filter(([lon, lat]) => isNumber(lon) && isNumber(lat));
-        const rawLinks = (_d = (_c = datamodel.data) === null || _c === void 0 ? void 0 : _c.links) !== null && _d !== void 0 ? _d : [];
-        for (let i = 0; i < rawLinks.length; i += 1) {
-            const link = rawLinks[i];
-            const slon = getNumber(link, config.sourceLongitude, i);
-            const slat = getNumber(link, config.sourceLatitude, i);
-            const tlon = getNumber(link, config.targetLongitude, i);
-            const tlat = getNumber(link, config.targetLatitude, i);
-            if (isNumber(slon) && isNumber(slat))
-                coordinates.push([slon, slat]);
-            if (isNumber(tlon) && isNumber(tlat))
-                coordinates.push([tlon, tlat]);
-        }
-        if (coordinates.length === 0)
-            return;
-        if (coordinates.length === 1) {
-            // Single point has zero-area bounds and breaks fitExtent; center the projection on the point
-            this._projection.center(coordinates[0]);
-            this._projection.translate([this._width / 2, this._height / 2]);
-        }
-        else {
-            const featureCollection = {
-                type: 'FeatureCollection',
-                features: [{
-                        type: 'Feature',
-                        properties: {},
-                        geometry: { type: 'MultiPoint', coordinates },
-                    }],
-            };
-            this._projection.fitExtent([
-                [this._width * pad, this._height * pad],
-                [this._width * (1 - pad), this._height * (1 - pad)],
-            ], featureCollection);
-            const maxScale = config.zoomExtent[1] * this._initialScale;
-            const fittedScale = this._projection.scale();
-            if (fittedScale > maxScale) {
-                const fittedTranslate = this._projection.translate();
-                const scaleRatio = maxScale / fittedScale;
-                this._projection.scale(maxScale);
-                this._projection.translate([
-                    this._width / 2 - (this._width / 2 - fittedTranslate[0]) * scaleRatio,
-                    this._height / 2 - (this._height / 2 - fittedTranslate[1]) * scaleRatio,
-                ]);
-            }
-        }
-        this._center = this._projection.translate();
-    }
-    _applyZoom() {
-        var _a;
-        const translate = (_a = this._center) !== null && _a !== void 0 ? _a : this._projection.translate();
-        const scale = this._initialScale * this._currentZoomLevel;
-        // Set an explicit pixel extent so D3 never falls back to defaultExtent2,
-        // which reads SVGLength.baseVal.value and throws on SVGs with % dimensions.
-        this._zoomBehavior.extent([[0, 0], [this._width, this._height]]);
-        this.g.call(this._zoomBehavior.transform, zoomIdentity.translate(translate[0], translate[1]).scale(scale));
-        this._isZooming = true;
-        this._onZoomEnd();
-    }
-    _onResize() {
-        this._isResizing = true;
-        const prevTranslate = this._projection.translate();
-        this._projection.fitExtent([[0, 0], [this._width, this._height]], this._featureCollection);
-        this._initialScale = this._projection.scale();
-        // If a point is selected, center the view on it after resize
-        if (this._selectedPoint) {
-            const coords = this._selectedPoint.geometry.coordinates;
-            const pos = this._projection(coords);
-            const projTranslate = this._projection.translate();
-            if (pos) {
-                const k = this._currentZoomLevel;
-                this._center = [
-                    this._width / 2 - (pos[0] - projTranslate[0]) * k,
-                    this._height / 2 - (pos[1] - projTranslate[1]) * k,
-                ];
-            }
-        }
-        else {
-            this._center = [
-                this._projection.translate()[0] * this._center[0] / prevTranslate[0],
-                this._projection.translate()[1] * this._center[1] / prevTranslate[1],
-            ];
-        }
-        this._applyZoom();
-        this._isResizing = false;
-        this._prevWidth = this._width;
-        this._prevHeight = this._height;
-    }
-    _onZoom(event) {
-        var _a, _b, _c, _d;
-        if (this._firstRender) {
-            // On first render, just update the zoom level, don't trigger animation
-            this._currentZoomLevel = ((event === null || event === void 0 ? void 0 : event.transform.k) / this._initialScale) || 1;
-            // Set CSS custom property for zoom level
-            (_b = (_a = this.g.node()) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.style.setProperty('--vis-map-current-zoom-level', String(this._currentZoomLevel));
-            return; // To prevent double render because of binding zoom behaviour
-        }
-        const isMouseEvent = !!event.sourceEvent;
-        const isExternalEvent = !(event === null || event === void 0 ? void 0 : event.sourceEvent) && !this._isResizing;
-        const isResizeEvent = this._isResizing && !(event === null || event === void 0 ? void 0 : event.sourceEvent);
-        this._isZooming = true;
-        // Clear any pending zoom end timeout
-        if (this._zoomEndTimeoutId) {
-            clearTimeout(this._zoomEndTimeoutId);
-        }
-        // Reset expanded cluster when manually zooming (but not during component-initiated zoom)
-        if (isMouseEvent && !this._eventInitiatedByComponent) {
-            this._resetExpandedCluster();
-            // Also clear the collapsed cluster state so points can naturally re-cluster at the new zoom level
-            this._collapsedCluster = null;
-            this._collapsedClusterPointIds = null;
-        }
-        window.cancelAnimationFrame(this._animFrameId);
-        this._animFrameId = window.requestAnimationFrame(this._onZoomHandler.bind(this, event.transform, isMouseEvent, isExternalEvent, isResizeEvent));
-        if (isMouseEvent) {
-            // Update the center coordinate so that the next call to _applyZoom()
-            // will zoom with respect to the current view
-            this._center = [event.transform.x, event.transform.y];
-        }
-        this._currentZoomLevel = ((event === null || event === void 0 ? void 0 : event.transform.k) / this._initialScale) || 1;
-        // Set CSS custom property for zoom level
-        (_d = (_c = this.g.node()) === null || _c === void 0 ? void 0 : _c.parentElement) === null || _d === void 0 ? void 0 : _d.style.setProperty('--vis-map-current-zoom-level', String(this._currentZoomLevel));
-        // Fallback timeout in case zoom end event doesn't fire
-        this._onZoomEnd();
-    }
-    _onZoomEnd() {
-        if (this._zoomEndTimeoutId) {
-            clearTimeout(this._zoomEndTimeoutId);
-        }
-        this._zoomEndTimeoutId = setTimeout(() => {
-            this._isZooming = false;
-            this._runCollisionDetection();
-        }, 150);
-    }
-    _runCollisionDetection() {
-        window.cancelAnimationFrame(this._collisionDetectionAnimFrameId);
-        this._collisionDetectionAnimFrameId = window.requestAnimationFrame(() => {
-            const duration = this.config.duration;
-            // Run collision detection for area labels
-            const areaLabels = this._areaLabelsGroup.selectAll(`.${areaLabel}`);
-            collideAreaLabels(areaLabels, duration);
-            // Run collision detection for point bottom labels
-            const pointBottomLabels = this._pointsGroup.selectAll(`.${point} .${pointBottomLabel}`);
-            collidePointBottomLabels(pointBottomLabels, duration);
-        });
-    }
-    _onZoomHandler(transform, isMouseEvent, isExternalEvent, isResizeEvent = false) {
-        const scale = transform.k / this._initialScale || 1;
-        const center = this._projection.translate();
-        this._transform = zoomIdentity
-            .translate(transform.x - center[0] * scale, transform.y - center[1] * scale)
-            .scale(scale);
-        const customDuration = (isExternalEvent || isResizeEvent)
-            ? this.config.zoomDuration
-            : (isMouseEvent ? 0 : null);
-        // Call render functions that depend on this._transform
-        this._renderGroups(customDuration);
-        this._renderAreaLabels(customDuration);
-        this._renderLinks(customDuration);
-        this._renderClusterBackground(customDuration);
-        this._renderPoints(customDuration);
-        this._renderSourcePoints(customDuration);
-    }
-    zoomIn(increment = 0.5) {
-        if (this._isZooming)
-            return;
-        this._resetExpandedCluster();
-        this.setZoom(this._currentZoomLevel + increment);
-    }
-    zoomOut(increment = 0.5) {
-        if (this._isZooming)
-            return;
-        this._resetExpandedCluster();
-        this.setZoom(this._currentZoomLevel - increment);
-    }
-    setZoom(zoomLevel) {
-        var _a, _b;
-        const { config } = this;
-        const newZoomLevel = clamp(zoomLevel, config.zoomExtent[0], config.zoomExtent[1]);
-        const currentK = this._initialScale * this._currentZoomLevel;
-        const newK = this._initialScale * newZoomLevel;
-        // Update _center so the viewport center stays fixed when zooming (avoids drift after pan)
-        if (currentK > 0 && isFinite(currentK) && isFinite(newK)) {
-            const ratio = newK / currentK;
-            this._center[0] = (this._width / 2 - this.bleed.left) * (1 - ratio) + this._center[0] * ratio;
-            this._center[1] = (this._height / 2 - this.bleed.top) * (1 - ratio) + this._center[1] * ratio;
-        }
-        this._currentZoomLevel = newZoomLevel;
-        // Set CSS custom property for zoom level
-        (_b = (_a = this.g.node()) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.style.setProperty('--vis-map-current-zoom-level', String(this._currentZoomLevel));
-        this._transform = zoomIdentity
-            .translate(this._center[0] * (1 - this._currentZoomLevel), this._center[1] * (1 - this._currentZoomLevel))
-            .scale(this._currentZoomLevel);
-        // We are using this._applyZoom() instead of directly calling this._render(config.zoomDuration) because
-        // we've to "attach" new transform to the map group element. Otherwise zoomBehavior  will not know
-        // that the zoom state has changed
-        this._applyZoom();
-    }
-    fitView() {
-        var _a, _b, _c, _d, _e;
-        const { config } = this;
-        this._resetExpandedCluster();
-        if (config.mapFitToPoints) {
-            // When mapFitToPoints is enabled, fitView should refit the projection to the points
-            // and reset the zoom level relative to that fitted scale.
-            this._fitToPoints();
-            // Treat the newly fitted scale as the baseline and reset zoom to 1
-            this._initialScale = this._projection.scale();
-            this._currentZoomLevel = 1;
-            (_b = (_a = this.g.node()) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.style.setProperty('--vis-map-current-zoom-level', '1');
-            this._center = this._projection.translate();
-            this._applyZoom();
-        }
-        else {
-            this._projection.fitExtent([[0, 0], [this._width, this._height]], this._featureCollection);
-            this._currentZoomLevel = (((_c = this._projection) === null || _c === void 0 ? void 0 : _c.scale()) / this._initialScale) || 1;
-            // Set CSS custom property for zoom level
-            (_e = (_d = this.g.node()) === null || _d === void 0 ? void 0 : _d.parentElement) === null || _e === void 0 ? void 0 : _e.style.setProperty('--vis-map-current-zoom-level', String(this._currentZoomLevel));
-            this._center = this._projection.translate();
-            // We are using this._applyZoom() instead of directly calling this._render(config.zoomDuration) because
-            // we've to "attach" new transform to the map group element. Otherwise zoomBehavior  will not know
-            // that the zoom state has changed
-            this._applyZoom();
-        }
-    }
-    _initFlowFeatures() {
-        initFlowFeatures(this);
-    }
-    _renderSourcePoints(duration) {
-        const { config } = this;
-        const sourcePoints = this._sourcePointsGroup
-            .selectAll(`.${sourcePoint}`)
-            .data(this._sourcePoints, (d, i) => `${d.flowData}-${i}`);
-        const sourcePointsEnter = sourcePoints.enter()
-            .append('circle')
-            .attr('class', sourcePoint)
-            .attr('cx', d => d.x)
-            .attr('cy', d => d.y)
-            .attr('r', d => d.radius / this._currentZoomLevel)
-            .style('fill', d => d.color)
-            .style('stroke', d => d.color)
-            .style('stroke-width', 0)
-            .style('opacity', 0)
-            .on('click', (event, d) => {
-            var _a;
-            event.stopPropagation();
-            (_a = config.onSourcePointClick) === null || _a === void 0 ? void 0 : _a.call(config, d.flowData, d.x, d.y, event);
-        })
-            .on('mouseenter', (event, d) => {
-            var _a;
-            (_a = config.onSourcePointMouseEnter) === null || _a === void 0 ? void 0 : _a.call(config, d.flowData, d.x, d.y, event);
-        })
-            .on('mouseleave', (event, d) => {
-            var _a;
-            (_a = config.onSourcePointMouseLeave) === null || _a === void 0 ? void 0 : _a.call(config, d.flowData, event);
-        });
-        smartTransition(sourcePointsEnter.merge(sourcePoints), duration)
-            .attr('cx', d => d.x)
-            .attr('cy', d => d.y)
-            .attr('r', d => d.radius / this._currentZoomLevel)
-            .style('opacity', 1);
-        sourcePoints.exit().remove();
-    }
-    _renderFlowParticles(duration) {
-        const flowParticles = this._flowParticlesGroup
-            .selectAll(`.${flowParticle}`)
-            .data(this._flowParticles, d => d.id);
-        const flowParticlesEnter = flowParticles.enter()
-            .append('circle')
-            .attr('class', flowParticle)
-            .attr('r', 0)
-            .style('opacity', 0);
-        smartTransition(flowParticlesEnter.merge(flowParticles), duration)
-            .attr('cx', d => d.x)
-            .attr('cy', d => d.y)
-            .attr('r', d => d.radius / (this._currentZoomLevel || 1))
-            .style('fill', d => d.color)
-            .style('opacity', 0.8);
-        flowParticles.exit().remove();
-    }
-    _startFlowAnimation() {
-        if (this._animationId)
-            return; // Animation already running
-        this._animateFlow();
-    }
-    _animateFlow() {
-        if (!this.config.enableFlowAnimation)
-            return;
-        this._animationId = requestAnimationFrame(() => {
-            this._updateFlowParticles();
-            this._animateFlow(); // Recursive call like LeafletFlowMap
-        });
-    }
-    _stopFlowAnimation() {
-        if (this._animationId) {
-            cancelAnimationFrame(this._animationId);
-            this._animationId = null;
-        }
-    }
-    _updateFlowParticles() {
-        updateFlowParticles({
-            _flowParticles: this._flowParticles,
-            _currentZoomLevel: this._currentZoomLevel,
-            _flowParticlesGroup: this._flowParticlesGroup,
-        });
-    }
-    _onPointClick(d, event) {
-        var _a;
-        const { config } = this;
-        event.stopPropagation();
-        // Clicking on expanded cluster points does nothing - they stay expanded
-        // (clicking outside on the map background will collapse them)
-        const expandedPoint = d;
-        if (expandedPoint.expandedClusterPoint) {
-            return;
-        }
-        if (d.isCluster && d.properties.cluster) {
-            const zoomLevel = this._currentZoomLevel || 1;
-            const coordinates = d.geometry.coordinates;
-            const zoomExtent = config.zoomExtent;
-            const zoomMax = (_a = zoomExtent === null || zoomExtent === void 0 ? void 0 : zoomExtent[1]) !== null && _a !== void 0 ? _a : 12;
-            if (config.clusterExpandOnClick) {
-                // Zoom to cluster and expand in one action
-                const newZoomLevel = getNextZoomLevelOnClusterClick(zoomLevel, zoomMax);
-                this._expandCluster(d);
-                this._zoomToLocation(coordinates, newZoomLevel);
-            }
-            else {
-                // Just zoom to cluster without expanding
-                const newZoomLevel = getNextZoomLevelOnClusterClick(zoomLevel, zoomMax);
-                this._zoomToLocation(coordinates, newZoomLevel);
-            }
-        }
-    }
-    _findClusterAtCoordinates(coordinates) {
-        const pointData = this._getPointData();
-        const [targetLon, targetLat] = coordinates;
-        // Find clusters and calculate their distance to the target coordinates
-        const clusters = pointData.filter(p => p.isCluster);
-        if (clusters.length === 0)
-            return undefined;
-        // Find the cluster closest to the target coordinates
-        let closestCluster;
-        let minDistance = Infinity;
-        for (const cluster of clusters) {
-            const [lon, lat] = cluster.geometry.coordinates;
-            const distance = Math.sqrt(Math.pow(lon - targetLon, 2) + Math.pow(lat - targetLat, 2));
-            if (distance < minDistance) {
-                minDistance = distance;
-                closestCluster = cluster;
-            }
-        }
-        return closestCluster;
-    }
-    _expandCluster(clusterPoint) {
-        const { config } = this;
-        if (!clusterPoint.clusterIndex) {
-            console.error('Cannot expand cluster - no clusterIndex!');
-            return undefined;
-        }
-        // Note: _collapsedCluster.id is numeric (e.g., 331), but clusterPoint.id is "cluster-331"
-        if (this._collapsedCluster && `cluster-${this._collapsedCluster.id}` === clusterPoint.id) {
-            this._collapsedCluster = null;
-            this._collapsedClusterPointIds = null;
-        }
-        const padding = 1;
-        const clusterId = clusterPoint.properties.clusterId;
-        const points = clusterPoint.clusterIndex.getLeaves(clusterId, Infinity);
-        // Determine packing zoom level. Cap at SUPERCLUSTER_MAX_ZOOM to avoid huge radii when
-        // zoomExtent[1] is large (e.g. 1000), which would cause incorrect expansion and weird animation.
-        const maxClusterZoomLevel = Array.isArray(config.zoomExtent) ? Math.min(config.zoomExtent[1], SUPERCLUSTER_MAX_ZOOM) : 16;
-        const packingZoomLevel = Math.min(this._currentZoomLevel || 1, maxClusterZoomLevel);
-        const packPoints = points.map((point) => {
-            return {
-                x: null,
-                y: null,
-                r: getPointRadius(point, config.pointRadius, packingZoomLevel) + padding,
-            };
-        });
-        packSiblings(packPoints);
-        // Create expanded points with relative positions
-        const expandedPoints = points.map((point, i) => {
-            var _a;
-            const originalData = point.properties;
-            const radius = getNumber(originalData, config.pointRadius) || 8;
-            const shape = getString(originalData, config.pointShape) || TopoJSONMapPointShape.Circle;
-            // Don't show pie charts for expanded cluster points (similar to Leaflet map)
-            const donutData = [];
-            // Use each point's own color (from colorMap or pointColor) so shapes keep their correct color when expanded
-            const explicitPointColor = getColor(originalData, config.pointColor);
-            const pointDonutData = getDonutData(originalData, config.colorMap);
-            const maxVal = pointDonutData.length ? Math.max(...pointDonutData.map(d => d.value)) : 0;
-            const biggestDatum = pointDonutData.find(d => d.value === maxVal) || pointDonutData[0];
-            const pointColor = (_a = explicitPointColor !== null && explicitPointColor !== void 0 ? explicitPointColor : biggestDatum === null || biggestDatum === void 0 ? void 0 : biggestDatum.color) !== null && _a !== void 0 ? _a : clusterPoint.color;
-            return {
-                geometry: { type: 'Point', coordinates: clusterPoint.geometry.coordinates },
-                bbox: { x1: 0, y1: 0, x2: 0, y2: 0 },
-                radius,
-                path: getPointPathData({ x: 0, y: 0 }, radius, shape),
-                color: pointColor,
-                id: getString(originalData, config.pointId, i) || `${clusterId}-${i}`,
-                properties: originalData,
-                donutData,
-                isCluster: false,
-                _zIndex: 1,
-                expandedClusterPoint: clusterPoint,
-                clusterColor: pointColor,
-                dx: packPoints[i].x,
-                dy: packPoints[i].y,
-                packedRadius: packPoints[i].r, // Store the packed radius for cluster background calculation
-            };
-        });
-        this._resetExpandedCluster();
-        this._expandedCluster = {
-            cluster: clusterPoint,
-            points: expandedPoints,
-        };
-        // Re-render to show expanded points and cluster background with smooth animation
-        this._renderClusterBackground(config.duration / 2);
-        this._renderPoints(config.duration / 2);
-        // Re-bind user-defined events to include newly created expanded cluster points
-        this._setUpComponentEventsThrottled();
-        this._setCustomAttributesThrottled();
-        // Return the original point data for centroid calculation
-        return points.map(p => p.properties);
-    }
-    _zoomToLocation(coordinates, zoomLevel) {
-        const { config } = this;
-        const clampedZoomLevel = clamp(zoomLevel, config.zoomExtent[0], config.zoomExtent[1]);
-        // Project the target coordinates using the current projection
-        const targetPoint = this._projection(coordinates);
-        if (!targetPoint)
-            return;
-        // Calculate the center of the viewport
-        const centerX = this._width / 2;
-        const centerY = this._height / 2;
-        // Calculate the scale factor
-        const k = this._initialScale * clampedZoomLevel;
-        // Calculate translation to center the target point
-        const currentCenter = this._projection.translate();
-        const x = centerX + (currentCenter[0] - targetPoint[0]) * (k / this._initialScale);
-        const y = centerY + (currentCenter[1] - targetPoint[1]) * (k / this._initialScale);
-        const transform = zoomIdentity.translate(x, y).scale(k);
-        // Update internal state
-        this._currentZoomLevel = clampedZoomLevel;
-        this._center = [x, y];
-        // Set flag to indicate this is a component-initiated zoom
-        this._eventInitiatedByComponent = true;
-        // Apply the transform with smooth eased animation
-        this.g
-            .transition()
-            .duration(config.zoomDuration)
-            .ease(easeCubicInOut)
-            .call(this._zoomBehavior.transform, transform)
-            .on('end', () => {
-            // Reset the flag after transition completes
-            this._eventInitiatedByComponent = false;
-        });
-    }
-    _collapseExpandedCluster() {
-        if (this._expandedCluster) {
-            this._resetExpandedCluster();
-            this._renderClusterBackground(this.config.duration);
-            this._renderPoints(this.config.duration);
-        }
-    }
-    _resetExpandedCluster() {
-        var _a;
-        if (this._expandedCluster) {
-            // Store the original cluster to restore it
-            const originalCluster = this._expandedCluster.cluster;
-            const expandedPointIds = new Set(this._expandedCluster.points.map((p) => getString(p.properties, this.config.pointId)));
-            // Convert the original cluster back to GeoJSON format for re-insertion
-            // Preserve critical fields: id (for cluster identification), clusterIndex (for re-expansion)
-            const clusterGeoJson = {
-                type: 'Feature',
-                id: originalCluster.properties.clusterId,
-                properties: Object.assign(Object.assign({}, originalCluster.properties), { clusterIndex: originalCluster.clusterIndex }),
-                geometry: originalCluster.geometry,
-            };
-            this._collapsedCluster = clusterGeoJson;
-            this._collapsedClusterPointIds = expandedPointIds;
-            // Clean up all references to prevent memory leaks
-            (_a = this._expandedCluster.points) === null || _a === void 0 ? void 0 : _a.forEach((d) => {
-                const expandedPoint = d;
-                delete expandedPoint.expandedClusterPoint;
-                delete expandedPoint.clusterColor;
-                delete expandedPoint.dx;
-                delete expandedPoint.dy;
-            });
-            this._expandedCluster = null;
-        }
-    }
-    /** Select a point by id */
-    selectPointById(id) {
-        const { config } = this;
-        const pointData = this._getPointData();
-        const foundPoint = pointData.find(d => getString(d.properties, config.pointId) === id);
-        if (foundPoint) {
-            this._selectedPoint = foundPoint;
-            this._renderPoints(config.duration);
-        }
-        else {
-            console.warn(`Unovis | TopoJSON Map: Point with id ${id} not found`);
-        }
-    }
-    /** Get the id of the selected point */
-    getSelectedPointId() {
-        var _a;
-        return (_a = this._selectedPoint) === null || _a === void 0 ? void 0 : _a.id;
-    }
-    /** Unselect point */
-    unselectPoint() {
-        this._selectedPoint = null;
-        this._renderPoints(this.config.duration);
-    }
-    destroy() {
-        window.cancelAnimationFrame(this._animFrameId);
-        this._stopFlowAnimation();
-        window.cancelAnimationFrame(this._collisionDetectionAnimFrameId);
-        if (this._zoomEndTimeoutId) {
-            clearTimeout(this._zoomEndTimeoutId);
-        }
-    }
-}
-TopoJSONMap.selectors = style;
-
-export { TopoJSONMap };
-//# sourceMappingURL=index.js.map