pretix-map 0.0.3__py3-none-any.whl

pretix_mapplugin/signals.py

@@ -0,0 +1,73 @@
+import logging
+from django.dispatch import receiver
+from django.http import HttpRequest  # For type hinting
+from django.urls import NoReverseMatch, reverse  # Import reverse and NoReverseMatch
+from django.utils.translation import gettext_lazy as _  # For translatable labels
+
+# --- Pretix Signals ---
+from pretix.base.signals import order_paid
+from pretix.control.signals import nav_event  # Import the navigation signal
+
+# --- Tasks ---
+from .tasks import geocode_order_task
+
+logger = logging.getLogger(__name__)
+
+# --- Constants ---
+MAP_VIEW_URL_NAME = 'plugins:pretix_mapplugin:event.settings.salesmap.show'
+# Define the permission required to see the map link
+REQUIRED_MAP_PERMISSION = 'can_view_orders'
+
+
+# --- Signal Receiver for Geocoding (Keep As Is) ---
+@receiver(order_paid, dispatch_uid="sales_mapper_order_paid_geocode")
+def trigger_geocoding_on_payment(sender, order, **kwargs):
+    # ... (keep your existing geocoding logic) ...
+    try:
+        geocode_order_task.apply_async(args=[order.pk])
+        logger.info(f"Geocoding task queued for paid order {order.code} (PK: {order.pk}).")
+    except NameError:
+        logger.error("geocode_order_task not found. Make sure it's imported correctly.")
+    except Exception as e:
+        logger.exception(f"Failed to queue geocoding task for order {order.code}: {e}")
+
+
+# --- Signal Receiver for Adding Navigation Item ---
+@receiver(nav_event, dispatch_uid="sales_mapper_nav_event_add_map")
+def add_map_nav_item(sender, request: HttpRequest, **kwargs):
+    """
+    Adds a navigation item for the Sales Map to the event control panel sidebar.
+    """
+    # Check if the user has the required permission for the current event
+    has_permission = request.user.has_event_permission(
+        request.organizer, request.event, REQUIRED_MAP_PERMISSION, request=request
+    )
+    if not has_permission:
+        return []  # Return empty list if user lacks permission
+
+    # Try to generate the URL for the map view
+    try:
+        map_url = reverse(MAP_VIEW_URL_NAME, kwargs={
+            'organizer': request.organizer.slug,
+            'event': request.event.slug,
+        })
+    except NoReverseMatch:
+        logger.error(f"Could not reverse URL for map view '{MAP_VIEW_URL_NAME}'. Check urls.py.")
+        return []  # Return empty list if URL cannot be generated
+
+    # Check if the current page *is* the map page to set the 'active' state
+    is_active = False
+    if hasattr(request, 'resolver_match') and request.resolver_match:
+        is_active = request.resolver_match.view_name == MAP_VIEW_URL_NAME
+
+    # Define the navigation item dictionary
+    nav_item = {
+        'label': _('Sales Map'),  # Translatable label
+        'url': map_url,
+        'active': is_active,
+        'icon': 'map-o',  # Font Awesome icon name (fa-map-o) - adjust if needed
+        # 'category': _('Orders'), # Optional: Suggests category, placement might vary
+    }
+
+    # Return the item in a list
+    return [nav_item]

pretix_mapplugin/static/pretix_mapplugin/css/salesmap.css

@@ -0,0 +1,19 @@
+#sales-map-container {
+    height: 500px;
+    width: 100%;
+    position: relative; /* Needed for Leaflet internal positioning */
+    background: #eee; /* Optional: Light background while tiles load */
+}
+
+#map-status-overlay p {
+    padding: 1em;
+    background: #fff;
+    border-radius: 5px;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+}
+
+#map-status-overlay p.text-danger { /* Style for error messages */
+    color: #a94442; /* Bootstrap danger color */
+    background-color: #f2dede; /* Bootstrap danger background */
+    border-color: #ebccd1; /* Bootstrap danger border */
+}

pretix_mapplugin/static/pretix_mapplugin/js/salesmap.js

@@ -0,0 +1,378 @@
+// Wait for the DOM to be fully loaded before running map code
+document.addEventListener('DOMContentLoaded', function () {
+    console.log("Sales Map JS Loaded (FINAL TEST - INCLUDING TOGGLE)");
+
+    // --- Configuration ---
+    const mapContainerId = 'sales-map-container';
+    const statusOverlayId = 'map-status-overlay';
+    const toggleButtonId = 'view-toggle-btn';
+    const initialZoom = 5;
+    const defaultMapView = 'pins'; // Can be 'pins' or 'heatmap'
+    const heatmapOptions = {
+        radius: 25,
+        blur: 15,
+        maxZoom: 18,
+        // max: 1.0, // Let leaflet-heat calculate max based on data density
+        minOpacity: 0.2
+    };
+
+    // --- Globals ---
+    let map = null; // Leaflet map instance
+    let coordinateData = []; // To store fetched [{lat: Y, lon: X, tooltip: Z}, ...] objects
+    let pinLayer = null; // Layer for markers/clusters
+    let heatmapLayer = null; // Layer for heatmap
+    let currentView = defaultMapView; // Track current view state
+    let dataUrl = null; // To store the API endpoint URL
+
+    const mapElement = document.getElementById(mapContainerId);
+    const statusOverlay = document.getElementById(statusOverlayId);
+    const toggleButton = document.getElementById(toggleButtonId);
+
+    // --- Helper to update status overlay ---
+    function updateStatus(message, isError = false) {
+        if (statusOverlay) {
+            const p = statusOverlay.querySelector('p');
+            if (p) {
+                p.textContent = message;
+                p.className = isError ? 'text-danger' : ''; // Apply error class if needed
+            }
+            statusOverlay.style.display = 'flex'; // Make sure it's visible
+        } else {
+            console.warn("Status overlay element not found.");
+        }
+    }
+
+    // --- Helper to hide status overlay ---
+    function hideStatus() {
+        if (statusOverlay) {
+            statusOverlay.style.display = 'none'; // Hide the overlay
+        }
+    }
+
+    // --- Initialization ---
+    function initializeMap() {
+        console.log("Initializing Leaflet map...");
+
+        if (!mapElement) {
+            console.error(`Map container element #${mapContainerId} not found.`);
+            return; // Stop initialization if container is missing
+        }
+        if (!statusOverlay) {
+            console.warn("Status overlay not found");
+        }
+        if (!toggleButton) {
+            // Log a warning but don't necessarily stop if button is missing
+            console.warn(`Toggle button #${toggleButtonId} not found.`);
+        }
+
+        // --- Get the data URL from the container's data attribute ---
+        dataUrl = mapElement.dataset.dataUrl;
+        if (!dataUrl) {
+            console.error("Data URL not found in container's data-data-url attribute! Cannot fetch data.");
+            updateStatus("Configuration Error: Missing data source URL.", true);
+            return; // Stop initialization if data URL is missing
+        }
+        console.log(`Data URL found: ${dataUrl}`);
+        // --- End data URL retrieval ---
+
+        // Set Leaflet default image path (if needed, depends on static file setup)
+        L.Icon.Default.imagePath = '/static/leaflet/images/'; // Ensure this path is correct
+        console.log("Set Leaflet default imagePath to:", L.Icon.Default.imagePath);
+
+        console.log("Initializing Leaflet map...");
+        updateStatus("Initializing map...");
+        try {
+            map = L.map(mapContainerId).setView([48.85, 2.35], initialZoom); // Default center
+            console.log("L.map() called successfully.");
+
+            console.log("Adding Tile Layer...");
+            L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+                attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
+            }).addTo(map);
+            console.log("Tile layer added successfully.");
+
+            // Setup toggle button listener if it exists
+            if (toggleButton) {
+                setupToggleButton(); // Call setup function
+            } else {
+                console.log("Toggle button not found, skipping listener setup.");
+            }
+
+            // Fetch data and populate the map layers
+            fetchCoordinateData();
+
+        } catch (error) {
+            console.error("ERROR during Leaflet initialization:", error);
+            updateStatus(`Leaflet Init Failed: ${error.message}`, true);
+        }
+    }
+
+    // --- Data Fetching ---
+    function fetchCoordinateData() {
+        // dataUrl should be set during initialization
+        if (!dataUrl) {
+            console.error("Cannot fetch data: dataUrl is not set.");
+            return;
+        }
+
+        console.log("Fetching coordinates from:", dataUrl);
+        updateStatus("Loading ticket locations..."); // Update status
+
+        fetch(dataUrl)
+            .then(response => {
+                if (!response.ok) {
+                    // Throw an error with status text to be caught below
+                    throw new Error(`HTTP error! Status: ${response.status} ${response.statusText}`);
+                }
+                return response.json();
+            })
+            .then(data => {
+                if (data.error) { // Check for application-level errors from the backend
+                    throw new Error(`API Error: ${data.error}`);
+                }
+                // --- Adjust check for the new data structure ---
+                if (!data || !data.locations || !Array.isArray(data.locations)) {
+                    console.warn("Invalid or empty data format received:", data);
+                    updateStatus("No valid geocoded ticket locations found.", false); // Inform user
+                    if (toggleButton) toggleButton.disabled = true; // Disable button if no data
+                    coordinateData = []; // Ensure it's empty
+                    return; // Stop processing if data is missing/invalid
+                }
+                if (data.locations.length === 0) {
+                    console.log("No coordinate data received (empty list).");
+                    updateStatus("No geocoded ticket locations found for this event.", false);
+                    if (toggleButton) toggleButton.disabled = true;
+                    coordinateData = [];
+                    return;
+                }
+                // --- End structure check ---
+
+                coordinateData = data.locations; // Store the [{lat: Y, lon: X, tooltip: Z}, ...] array
+                console.log(`Received ${coordinateData.length} coordinates.`);
+
+                // --- Create layers (but don't add to map yet) ---
+                createMapLayers();
+
+                // --- Show the default view ---
+                showCurrentView();
+
+                // Adjust map bounds to fit markers if coordinates were found
+                adjustMapBounds();
+
+                // Enable button if it was disabled and we got data
+                if (toggleButton) toggleButton.disabled = false;
+                hideStatus();
+
+                // Force redraw just in case (sometimes needed after dynamic content/bounds changes)
+                setTimeout(function () {
+                    console.log("Forcing map.invalidateSize() after data load...");
+                    console.log("Map container element just before invalidateSize:", document.getElementById(mapContainerId)); // Check if it exists here
+                    if (map && document.getElementById(mapContainerId)) { // Add check before calling
+                        map.invalidateSize();
+                    } else {
+                        console.warn("Skipping invalidateSize because map or container is missing.");
+                    }
+                }, 100);
+
+            })
+            .catch(error => {
+                console.error('Error fetching or processing coordinate data:', error);
+                console.log("Map container element during fetch error:", document.getElementById(mapContainerId)); // Check if it exists here
+                updateStatus(`Error loading map data: ${error.message}. Please try again later.`, true); // Show error in overlay
+                if (toggleButton) toggleButton.disabled = true;
+            });
+    }
+
+    // --- Layer Creation ---
+    function createMapLayers() {
+        if (!map || coordinateData.length === 0) {
+            console.log("Skipping layer creation (no map or data).");
+            return;
+        }
+
+        // 1. Create Pin Layer (using MarkerCluster)
+        console.log("Creating pin layer instance (marker cluster)...");
+        pinLayer = L.markerClusterGroup(); // Initialize cluster group
+        coordinateData.forEach((loc, index) => { // loc is now {lat, lon, tooltip, order_url}
+            try {
+                if (loc.lat == null || loc.lon == null) { /* ... skip invalid ... */
+                    return;
+                }
+                const latLng = L.latLng(loc.lat, loc.lon);
+                if (isNaN(latLng.lat) || isNaN(latLng.lng)) { /* ... skip invalid ... */
+                    return;
+                }
+
+                const marker = L.marker(latLng);
+
+                // --- Use the enhanced tooltip from backend ---
+                // Leaflet tooltips handle HTML content by default
+                if (loc.tooltip) {
+                    marker.bindTooltip(loc.tooltip);
+                }
+                // --- End Tooltip ---
+
+                // --- Add Click Listener to open order URL ---
+                if (loc.order_url) { // Only add listener if URL was successfully generated
+                    marker.on('click', function () {
+                        console.log(`Marker clicked, opening URL: ${loc.order_url}`);
+                        // Open in a new tab, which is usually better for control panel links
+                        window.open(loc.order_url, '_blank');
+                        // If you prefer opening in the same tab:
+                        // window.location.href = loc.order_url;
+                    });
+                } else {
+                    // Log if URL is missing for a marker, maybe backend issue
+                    console.warn(`Order URL missing for coordinate index ${index}, click disabled for this marker.`);
+                }
+                // --- End Click Listener ---
+
+                pinLayer.addLayer(marker); // Add marker to cluster group
+
+            } catch (e) {
+                console.error(`Error creating marker for coordinate ${index}:`, loc, e);
+            }
+        });
+        console.log("Pin layer instance created with markers (incl. tooltips and clicks).");
+
+
+        // 2. Create Heatmap Layer (No changes needed here)
+        console.log("Creating heatmap layer instance...");
+        try {
+            const heatPoints = coordinateData.map(loc => {
+                if (loc.lat != null && loc.lon != null && !isNaN(loc.lat) && !isNaN(loc.lon)) {
+                    return [loc.lat, loc.lon, 1.0];
+                }
+                return null;
+            }).filter(p => p !== null);
+
+            if (heatPoints.length > 0) {
+                heatmapLayer = L.heatLayer(heatPoints, heatmapOptions);
+                console.log("Heatmap layer instance created.");
+            } else { /* ... handle no valid points ... */
+                heatmapLayer = null;
+            }
+        } catch (e) { /* ... error handling ... */
+            heatmapLayer = null;
+        }
+
+        console.log("Map layer instances created/updated.");
+    }
+
+    // --- Adjust Map Bounds ---
+    function adjustMapBounds() {
+        if (!map || coordinateData.length === 0) return;
+
+        try {
+            let bounds = null;
+            // Prefer using marker cluster bounds if available and valid
+            if (pinLayer && typeof pinLayer.getBounds === 'function') {
+                bounds = pinLayer.getBounds();
+                console.log("Attempting to get bounds from pin layer (marker cluster).");
+            }
+
+            // If no valid bounds from cluster, or only heatmap exists, calculate from raw data
+            if (!bounds || !bounds.isValid()) {
+                console.log("Pin layer bounds invalid or unavailable, calculating bounds from raw coordinates.");
+                const latLngs = coordinateData
+                    .map(loc => {
+                        if (loc.lat != null && loc.lon != null && !isNaN(loc.lat) && !isNaN(loc.lon)) {
+                            return [loc.lat, loc.lon];
+                        }
+                        return null;
+                    })
+                    .filter(p => p !== null);
+
+                if (latLngs.length > 0) {
+                    bounds = L.latLngBounds(latLngs);
+                }
+            }
+
+            // Fit map to bounds if valid bounds were found
+            if (bounds && bounds.isValid()) {
+                console.log("Fitting map to calculated bounds...");
+                map.fitBounds(bounds, {padding: [50, 50]}); // Add padding
+                console.log("Bounds fitted.");
+            } else if (coordinateData.length === 1) {
+                // Special case for a single point
+                console.log("Only one valid coordinate, setting view directly.");
+                const singleCoord = coordinateData.find(loc => loc.lat != null && loc.lon != null && !isNaN(loc.lat) && !isNaN(loc.lon));
+                if (singleCoord) {
+                    map.setView([singleCoord.lat, singleCoord.lon], 13); // Zoom level 13 for single point
+                } else {
+                    console.warn("Could not find the single valid coordinate to set view.");
+                }
+            } else {
+                console.warn("Could not determine valid bounds to fit the map.");
+            }
+        } catch (e) {
+            console.error("Error fitting map bounds:", e);
+        }
+    }
+
+    // --- View Toggling ---
+    function setupToggleButton() {
+        updateButtonText(); // Set initial text
+        toggleButton.addEventListener('click', () => {
+            console.log("Toggle button clicked!");
+            currentView = (currentView === 'pins') ? 'heatmap' : 'pins';
+            showCurrentView(); // Update the map layers
+            updateButtonText(); // Update the button text
+        });
+        console.log("Toggle button listener setup complete.");
+    }
+
+    function showCurrentView() {
+        console.log(`Showing view: ${currentView}`);
+        if (!map) {
+            console.warn("Map not initialized, cannot show view.");
+            return;
+        }
+
+        // --- Safely remove existing layers ---
+        console.log("Removing existing layers (if present)...");
+        if (pinLayer && map.hasLayer(pinLayer)) {
+            map.removeLayer(pinLayer);
+            console.log("Removed pin layer");
+        }
+        if (heatmapLayer && map.hasLayer(heatmapLayer)) {
+            map.removeLayer(heatmapLayer);
+            console.log("Removed heatmap layer");
+        }
+        // --- End removal ---
+
+        // --- Add the selected layer ---
+        console.log(`Adding ${currentView} layer...`);
+        try {
+            if (currentView === 'pins' && pinLayer) {
+                map.addLayer(pinLayer);
+                console.log("Added pin layer to map.");
+            } else if (currentView === 'heatmap' && heatmapLayer) {
+                map.addLayer(heatmapLayer);
+                console.log("Added heatmap layer to map.");
+            } else {
+                console.warn(`Cannot add layer for view "${currentView}": Corresponding layer instance is missing or null.`);
+                // Maybe display a message if no layers could be shown?
+                mapElement.innerHTML += '<p style="position: absolute; top: 10px; left: 50px; background: yellow; padding: 5px; z-index: 1000;">No data to display for this view.</p>';
+                setTimeout(() => { // Clear message after a few seconds
+                    const msgElement = mapElement.querySelector('p[style*="yellow"]');
+                    if (msgElement) msgElement.remove();
+                }, 3000);
+            }
+        } catch (e) {
+            console.error(`Error adding ${currentView} layer:`, e);
+        }
+        // --- End adding ---
+    }
+
+    function updateButtonText() {
+        if (!toggleButton) return;
+        const nextViewText = (currentView === 'pins') ? 'Heatmap' : 'Pin';
+        toggleButton.textContent = `Switch to ${nextViewText} View`;
+        console.log(`Button text updated to: ${toggleButton.textContent}`);
+    }
+
+    // --- Start ---
+    initializeMap();
+
+}); // End DOMContentLoaded

pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/MarkerCluster.Default.css

@@ -0,0 +1,60 @@
+.marker-cluster-small {
+	background-color: rgba(181, 226, 140, 0.6);
+	}
+.marker-cluster-small div {
+	background-color: rgba(110, 204, 57, 0.6);
+	}
+
+.marker-cluster-medium {
+	background-color: rgba(241, 211, 87, 0.6);
+	}
+.marker-cluster-medium div {
+	background-color: rgba(240, 194, 12, 0.6);
+	}
+
+.marker-cluster-large {
+	background-color: rgba(253, 156, 115, 0.6);
+	}
+.marker-cluster-large div {
+	background-color: rgba(241, 128, 23, 0.6);
+	}
+
+	/* IE 6-8 fallback colors */
+.leaflet-oldie .marker-cluster-small {
+	background-color: rgb(181, 226, 140);
+	}
+.leaflet-oldie .marker-cluster-small div {
+	background-color: rgb(110, 204, 57);
+	}
+
+.leaflet-oldie .marker-cluster-medium {
+	background-color: rgb(241, 211, 87);
+	}
+.leaflet-oldie .marker-cluster-medium div {
+	background-color: rgb(240, 194, 12);
+	}
+
+.leaflet-oldie .marker-cluster-large {
+	background-color: rgb(253, 156, 115);
+	}
+.leaflet-oldie .marker-cluster-large div {
+	background-color: rgb(241, 128, 23);
+}
+
+.marker-cluster {
+	background-clip: padding-box;
+	border-radius: 20px;
+	}
+.marker-cluster div {
+	width: 30px;
+	height: 30px;
+	margin-left: 5px;
+	margin-top: 5px;
+
+	text-align: center;
+	border-radius: 15px;
+	font: 12px "Helvetica Neue", Arial, Helvetica, sans-serif;
+	}
+.marker-cluster span {
+	line-height: 30px;
+	}

pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/MarkerCluster.css

@@ -0,0 +1,14 @@
+.leaflet-cluster-anim .leaflet-marker-icon, .leaflet-cluster-anim .leaflet-marker-shadow {
+	-webkit-transition: -webkit-transform 0.3s ease-out, opacity 0.3s ease-in;
+	-moz-transition: -moz-transform 0.3s ease-out, opacity 0.3s ease-in;
+	-o-transition: -o-transform 0.3s ease-out, opacity 0.3s ease-in;
+	transition: transform 0.3s ease-out, opacity 0.3s ease-in;
+}
+
+.leaflet-cluster-spider-leg {
+	/* stroke-dashoffset (duration and function) should match with leaflet-marker-icon transform in order to track it exactly */
+	-webkit-transition: -webkit-stroke-dashoffset 0.3s ease-out, -webkit-stroke-opacity 0.3s ease-in;
+	-moz-transition: -moz-stroke-dashoffset 0.3s ease-out, -moz-stroke-opacity 0.3s ease-in;
+	-o-transition: -o-stroke-dashoffset 0.3s ease-out, -o-stroke-opacity 0.3s ease-in;
+	transition: stroke-dashoffset 0.3s ease-out, stroke-opacity 0.3s ease-in;
+}

pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/leaflet-heat.js

@@ -0,0 +1,11 @@
+/*
+ (c) 2014, Vladimir Agafonkin
+ simpleheat, a tiny JavaScript library for drawing heatmaps with Canvas
+ https://github.com/mourner/simpleheat
+*/
+!function(){"use strict";function t(i){return this instanceof t?(this._canvas=i="string"==typeof i?document.getElementById(i):i,this._ctx=i.getContext("2d"),this._width=i.width,this._height=i.height,this._max=1,void this.clear()):new t(i)}t.prototype={defaultRadius:25,defaultGradient:{.4:"blue",.6:"cyan",.7:"lime",.8:"yellow",1:"red"},data:function(t,i){return this._data=t,this},max:function(t){return this._max=t,this},add:function(t){return this._data.push(t),this},clear:function(){return this._data=[],this},radius:function(t,i){i=i||15;var a=this._circle=document.createElement("canvas"),s=a.getContext("2d"),e=this._r=t+i;return a.width=a.height=2*e,s.shadowOffsetX=s.shadowOffsetY=200,s.shadowBlur=i,s.shadowColor="black",s.beginPath(),s.arc(e-200,e-200,t,0,2*Math.PI,!0),s.closePath(),s.fill(),this},gradient:function(t){var i=document.createElement("canvas"),a=i.getContext("2d"),s=a.createLinearGradient(0,0,0,256);i.width=1,i.height=256;for(var e in t)s.addColorStop(e,t[e]);return a.fillStyle=s,a.fillRect(0,0,1,256),this._grad=a.getImageData(0,0,1,256).data,this},draw:function(t){this._circle||this.radius(this.defaultRadius),this._grad||this.gradient(this.defaultGradient);var i=this._ctx;i.clearRect(0,0,this._width,this._height);for(var a,s=0,e=this._data.length;e>s;s++)a=this._data[s],i.globalAlpha=Math.max(a[2]/this._max,t||.05),i.drawImage(this._circle,a[0]-this._r,a[1]-this._r);var n=i.getImageData(0,0,this._width,this._height);return this._colorize(n.data,this._grad),i.putImageData(n,0,0),this},_colorize:function(t,i){for(var a,s=3,e=t.length;e>s;s+=4)a=4*t[s],a&&(t[s-3]=i[a],t[s-2]=i[a+1],t[s-1]=i[a+2])}},window.simpleheat=t}(),/*
+ (c) 2014, Vladimir Agafonkin
+ Leaflet.heat, a tiny and fast heatmap plugin for Leaflet.
+ https://github.com/Leaflet/Leaflet.heat
+*/
+L.HeatLayer=(L.Layer?L.Layer:L.Class).extend({initialize:function(t,i){this._latlngs=t,L.setOptions(this,i)},setLatLngs:function(t){return this._latlngs=t,this.redraw()},addLatLng:function(t){return this._latlngs.push(t),this.redraw()},setOptions:function(t){return L.setOptions(this,t),this._heat&&this._updateOptions(),this.redraw()},redraw:function(){return!this._heat||this._frame||this._map._animating||(this._frame=L.Util.requestAnimFrame(this._redraw,this)),this},onAdd:function(t){this._map=t,this._canvas||this._initCanvas(),t._panes.overlayPane.appendChild(this._canvas),t.on("moveend",this._reset,this),t.options.zoomAnimation&&L.Browser.any3d&&t.on("zoomanim",this._animateZoom,this),this._reset()},onRemove:function(t){t.getPanes().overlayPane.removeChild(this._canvas),t.off("moveend",this._reset,this),t.options.zoomAnimation&&t.off("zoomanim",this._animateZoom,this)},addTo:function(t){return t.addLayer(this),this},_initCanvas:function(){var t=this._canvas=L.DomUtil.create("canvas","leaflet-heatmap-layer leaflet-layer"),i=L.DomUtil.testProp(["transformOrigin","WebkitTransformOrigin","msTransformOrigin"]);t.style[i]="50% 50%";var a=this._map.getSize();t.width=a.x,t.height=a.y;var s=this._map.options.zoomAnimation&&L.Browser.any3d;L.DomUtil.addClass(t,"leaflet-zoom-"+(s?"animated":"hide")),this._heat=simpleheat(t),this._updateOptions()},_updateOptions:function(){this._heat.radius(this.options.radius||this._heat.defaultRadius,this.options.blur),this.options.gradient&&this._heat.gradient(this.options.gradient),this.options.max&&this._heat.max(this.options.max)},_reset:function(){var t=this._map.containerPointToLayerPoint([0,0]);L.DomUtil.setPosition(this._canvas,t);var i=this._map.getSize();this._heat._width!==i.x&&(this._canvas.width=this._heat._width=i.x),this._heat._height!==i.y&&(this._canvas.height=this._heat._height=i.y),this._redraw()},_redraw:function(){var t,i,a,s,e,n,h,o,r,d=[],_=this._heat._r,l=this._map.getSize(),m=new L.Bounds(L.point([-_,-_]),l.add([_,_])),c=void 0===this.options.max?1:this.options.max,u=void 0===this.options.maxZoom?this._map.getMaxZoom():this.options.maxZoom,f=1/Math.pow(2,Math.max(0,Math.min(u-this._map.getZoom(),12))),g=_/2,p=[],v=this._map._getMapPanePos(),w=v.x%g,y=v.y%g;for(t=0,i=this._latlngs.length;i>t;t++)if(a=this._map.latLngToContainerPoint(this._latlngs[t]),m.contains(a)){e=Math.floor((a.x-w)/g)+2,n=Math.floor((a.y-y)/g)+2;var x=void 0!==this._latlngs[t].alt?this._latlngs[t].alt:void 0!==this._latlngs[t][2]?+this._latlngs[t][2]:1;r=x*f,p[n]=p[n]||[],s=p[n][e],s?(s[0]=(s[0]*s[2]+a.x*r)/(s[2]+r),s[1]=(s[1]*s[2]+a.y*r)/(s[2]+r),s[2]+=r):p[n][e]=[a.x,a.y,r]}for(t=0,i=p.length;i>t;t++)if(p[t])for(h=0,o=p[t].length;o>h;h++)s=p[t][h],s&&d.push([Math.round(s[0]),Math.round(s[1]),Math.min(s[2],c)]);this._heat.data(d).draw(this.options.minOpacity),this._frame=null},_animateZoom:function(t){var i=this._map.getZoomScale(t.zoom),a=this._map._getCenterOffset(t.center)._multiplyBy(-i).subtract(this._map._getMapPanePos());L.DomUtil.setTransform?L.DomUtil.setTransform(this._canvas,a,i):this._canvas.style[L.DomUtil.TRANSFORM]=L.DomUtil.getTranslateString(a)+" scale("+i+")"}}),L.heatLayer=function(t,i){return new L.HeatLayer(t,i)};