@smartnet360/svelte-components 0.0.92 → 0.0.94

package/dist/map-v3/demo/DemoMap.svelte

@@ -30,9 +30,9 @@
 	let { accessToken }: Props = $props();
 
 	// Initialize stores
-	const cellData = createCellDataStore();
 	const cellRegistry = createCellRegistry('demo-map');
 	const cellDisplay = new CellDisplayStore();
+	const cellData = createCellDataStore(cellDisplay);
 
 	const siteData = createSiteDataStore(cellData);
 	const siteRegistry = createSiteRegistry('demo-map');

package/dist/map-v3/features/cells/components/CellSettingsPanel.svelte

@@ -115,6 +115,84 @@
 					</select>
 				</div>
 			</div>
+			
+			<!-- Neighbor Count -->
+			<div class="row align-items-center g-2 mb-3 ps-3">
+				<div class="col-4 text-secondary small">Neighbors</div>
+				<div class="col-3 text-end">
+					<span class="badge bg-white text-muted border">{displayStore.autoSizeNeighborCount}</span>
+				</div>
+				<div class="col-5">
+					<input
+						type="range"
+						class="form-range w-100"
+						min="1"
+						max="10"
+						step="1"
+						bind:value={displayStore.autoSizeNeighborCount}
+						title="Number of nearest neighbors to average for density calculation"
+					/>
+				</div>
+			</div>
+			
+			<!-- Size Multiplier -->
+			<div class="row align-items-center g-2 mb-3 ps-3">
+				<div class="col-4 text-secondary small">Size Scale</div>
+				<div class="col-3 text-end">
+					<span class="badge bg-white text-muted border">{displayStore.autoSizeMultiplier.toFixed(1)}x</span>
+				</div>
+				<div class="col-5">
+					<input
+						type="range"
+						class="form-range w-100"
+						min="0.3"
+						max="2.0"
+						step="0.1"
+						bind:value={displayStore.autoSizeMultiplier}
+						title="Scale all auto-sized cells up or down"
+					/>
+				</div>
+			</div>
+			
+			<!-- Grid-Based Outlier Capping -->
+			<div class="row align-items-center g-2 mb-3 ps-3">
+				<div class="col-4 text-secondary small">Grid Capping</div>
+				<div class="col-8">
+					<div class="form-check form-switch">
+						<input
+							class="form-check-input"
+							type="checkbox"
+							id="gridCappingToggle"
+							bind:checked={displayStore.useGridCapping}
+							title="Remove outliers using grid-based percentile capping"
+						/>
+						<label class="form-check-label small" for="gridCappingToggle">
+							Remove outliers
+						</label>
+					</div>
+				</div>
+			</div>
+			
+			{#if displayStore.useGridCapping}
+				<!-- Grid Cap Percentile -->
+				<div class="row align-items-center g-2 mb-3 ps-3">
+					<div class="col-4 text-secondary small">Cap Percentile</div>
+					<div class="col-3 text-end">
+						<span class="badge bg-white text-muted border">{displayStore.gridCapPercentile}th</span>
+					</div>
+					<div class="col-5">
+						<input
+							type="range"
+							class="form-range w-100"
+							min="70"
+							max="95"
+							step="5"
+							bind:value={displayStore.gridCapPercentile}
+							title="Percentile threshold for capping outliers within each grid"
+						/>
+					</div>
+				</div>
+			{/if}
 		{/if}
 
 		<div class="border-top my-3"></div>

package/dist/map-v3/features/cells/layers/CellsLayer.svelte

@@ -102,8 +102,13 @@
 
 		// Events for updating
 		map.on('style.load', addLayers);
-		map.on('moveend', updateLayer);
-		map.on('zoomend', updateLayer);
+		
+		// Only listen to map events when NOT using auto-size
+		// Auto-size uses fixed meter-based sizes that don't change with zoom
+		if (!displayStore.useAutoSize) {
+			map.on('moveend', updateLayer);
+			map.on('zoomend', updateLayer);
+		}
 
 		// Cleanup
 		return () => {
@@ -129,6 +134,11 @@
 		const _layerGrouping = displayStore.layerGrouping;
 		const _useAutoSize = displayStore.useAutoSize;
 		const _autoSizeMode = displayStore.autoSizeMode;
+		const _autoSizeNeighborCount = displayStore.autoSizeNeighborCount;
+		const _autoSizeMultiplier = displayStore.autoSizeMultiplier;
+		const _useGridCapping = displayStore.useGridCapping;
+		const _gridCapPercentile = displayStore.gridCapPercentile;
+		const _gridSizeKm = displayStore.gridSizeKm;
 		
 		updateLayer();
 	});
@@ -144,20 +154,22 @@
 	}
 
 	function renderCells(map: mapboxgl.Map) {
-		const bounds = map.getBounds();
-		if (!bounds) return;
-
-		const zoom = map.getZoom();
-		const centerLat = map.getCenter().lat;
+		const useAutoSize = displayStore.useAutoSize;
 		
-		console.log(`[CellsLayer] Rendering.. Zoom: ${zoom.toFixed(2)}, Cells: ${dataStore.filteredCells.length}`);
+		// Only need bounds checking and zoom calculations for manual mode
+		const bounds = useAutoSize ? null : map.getBounds();
+		const zoom = useAutoSize ? 0 : map.getZoom();
+		const centerLat = useAutoSize ? 0 : map.getCenter().lat;
+		
+		console.log(`[CellsLayer] Rendering ${dataStore.filteredCells.length} cells (auto-size: ${useAutoSize})`);
 
-		// 1. Calculate base radius
-		const baseRadiusMeters = calculateRadiusInMeters(centerLat, zoom, displayStore.targetPixelSize);
-		console.log(`[CellsLayer] Base radius: ${baseRadiusMeters.toFixed(2)}m for target ${displayStore.targetPixelSize}px`);
+		// 1. Calculate base radius (only for manual mode)
+		const baseRadiusMeters = useAutoSize ? 0 : calculateRadiusInMeters(centerLat, zoom, displayStore.targetPixelSize);
+		if (!useAutoSize) {
+			console.log(`[CellsLayer] Base radius: ${baseRadiusMeters.toFixed(2)}m for target ${displayStore.targetPixelSize}px at zoom ${zoom.toFixed(2)}`);
+		}
 
-		// 2. Group cells (Level 1=Tech, Level 2=Band for now hardcoded)
-		// In real app, this comes from a store
+		// 2. Group cells
 		const groups = groupCells(dataStore.filteredCells, displayStore.level1, displayStore.level2);
 		console.log(`[CellsLayer] Groups: ${groups.size}`);
 		
@@ -173,13 +185,17 @@
 			if (!style.visible) continue;
 
 			for (const cell of cells) {
-				// 4. BBox Filter (Simple point check)
-				if (bounds.contains([cell.longitude, cell.latitude])) {
+				// 4. BBox Filter (skip for auto-size - Mapbox handles culling efficiently)
+				const inView = useAutoSize ? true : (bounds?.contains([cell.longitude, cell.latitude]) ?? false);
+				
+				if (inView) {
 					// 5. Z-Index Lookup
 					const zIndexKey = `${cell.tech}_${cell.frq}` as TechnologyBandKey;
 					const zIndex = displayStore.currentZIndex[zIndexKey] ?? 10;
 
-					// 6. Calculate radius with z-index scaling
+					// 6. Calculate radius
+					// Auto-size: Fixed meter-based size from site density
+					// Manual: Pixel-based size that scales with zoom
 					const MAX_Z = 35;
 					let radiusMeters: number;
 					
@@ -188,10 +204,13 @@
 						const siteDistance = dataStore.siteDistanceStore.getDistance(cell.siteId, 500);
 						const autoRadius = calculateAutoRadius(siteDistance, displayStore.autoSizeMode);
 						
+						// Apply user's multiplier to scale the result
+						const adjustedAutoRadius = autoRadius * displayStore.autoSizeMultiplier;
+						
 						// Scale based on z-index for stacking visibility
 						// Lower z-index (background) = larger, higher z-index (foreground) = smaller
 						const scaleFactor = 1 + Math.max(0, MAX_Z - zIndex) * 0.08; // 8% per layer
-						radiusMeters = autoRadius * scaleFactor;
+						radiusMeters = adjustedAutoRadius * scaleFactor;
 					} else {
 						// Manual mode: base from pixel size, then scale by z-index
 						const scaleFactor = 1 + Math.max(0, MAX_Z - zIndex) * 0.08;

package/dist/map-v3/features/cells/logic/grid-density.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Grid-Based Density Calculation
+ *
+ * Divides map into fixed-size grids and computes density-based size caps
+ * Used to remove outliers and create visual uniformity within local areas
+ */
+import type { Cell } from '../types';
+/**
+ * Convert geographic coordinates to grid key
+ * @param lon Longitude
+ * @param lat Latitude
+ * @param gridSizeKm Size of grid cell in kilometers (default: 1km)
+ * @returns Grid key string "x_y"
+ */
+export declare function getGridKey(lon: number, lat: number, gridSizeKm?: number): string;
+/**
+ * Group cells by grid
+ * @param cells Array of cells
+ * @param gridSizeKm Grid size in kilometers
+ * @returns Map of gridKey -> cells in that grid
+ */
+export declare function groupCellsByGrid(cells: Cell[], gridSizeKm?: number): Map<string, Cell[]>;
+/**
+ * Calculate percentile value from array
+ * @param values Sorted array of numbers
+ * @param percentile Percentile to calculate (0-100, e.g., 80 for 80th percentile)
+ * @returns Value at the given percentile
+ */
+export declare function calculatePercentile(values: number[], percentile: number): number;
+/**
+ * Compute grid-based size caps using percentile
+ * @param cells Array of cells
+ * @param sizeMap Map of siteId -> calculated size
+ * @param percentile Percentile threshold (0-100, e.g., 80)
+ * @param gridSizeKm Grid size in kilometers
+ * @param minCellsForCapping Minimum cells in grid to apply capping (default: 3)
+ * @returns Map of siteId -> capped size
+ */
+export declare function computeGridBasedSizeCaps(cells: Cell[], sizeMap: Map<string, number>, percentile: number, gridSizeKm?: number, minCellsForCapping?: number): Map<string, number>;
+/**
+ * Get statistics about grid-based capping
+ * @param originalSizes Map of original sizes
+ * @param cappedSizes Map of capped sizes
+ * @returns Object with statistics
+ */
+export declare function getGridCappingStats(originalSizes: Map<string, number>, cappedSizes: Map<string, number>): {
+    totalSites: number;
+    cappedSites: number;
+    cappedPercentage: number;
+    avgReduction: number;
+};

package/dist/map-v3/features/cells/logic/grid-density.js

@@ -0,0 +1,138 @@
+/**
+ * Grid-Based Density Calculation
+ *
+ * Divides map into fixed-size grids and computes density-based size caps
+ * Used to remove outliers and create visual uniformity within local areas
+ */
+/**
+ * Convert geographic coordinates to grid key
+ * @param lon Longitude
+ * @param lat Latitude
+ * @param gridSizeKm Size of grid cell in kilometers (default: 1km)
+ * @returns Grid key string "x_y"
+ */
+export function getGridKey(lon, lat, gridSizeKm = 1) {
+    // Approximate: 1 degree ≈ 111km at equator
+    // This is rough but sufficient for grouping
+    const degreesPerGrid = gridSizeKm / 111;
+    const gridX = Math.floor(lon / degreesPerGrid);
+    const gridY = Math.floor(lat / degreesPerGrid);
+    return `${gridX}_${gridY}`;
+}
+/**
+ * Group cells by grid
+ * @param cells Array of cells
+ * @param gridSizeKm Grid size in kilometers
+ * @returns Map of gridKey -> cells in that grid
+ */
+export function groupCellsByGrid(cells, gridSizeKm = 1) {
+    const grids = new Map();
+    for (const cell of cells) {
+        const gridKey = getGridKey(cell.longitude, cell.latitude, gridSizeKm);
+        if (!grids.has(gridKey)) {
+            grids.set(gridKey, []);
+        }
+        grids.get(gridKey).push(cell);
+    }
+    return grids;
+}
+/**
+ * Calculate percentile value from array
+ * @param values Sorted array of numbers
+ * @param percentile Percentile to calculate (0-100, e.g., 80 for 80th percentile)
+ * @returns Value at the given percentile
+ */
+export function calculatePercentile(values, percentile) {
+    if (values.length === 0)
+        return Infinity;
+    if (values.length === 1)
+        return values[0];
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = (percentile / 100) * (sorted.length - 1);
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    const weight = index % 1;
+    if (lower === upper) {
+        return sorted[lower];
+    }
+    return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+}
+/**
+ * Compute grid-based size caps using percentile
+ * @param cells Array of cells
+ * @param sizeMap Map of siteId -> calculated size
+ * @param percentile Percentile threshold (0-100, e.g., 80)
+ * @param gridSizeKm Grid size in kilometers
+ * @param minCellsForCapping Minimum cells in grid to apply capping (default: 3)
+ * @returns Map of siteId -> capped size
+ */
+export function computeGridBasedSizeCaps(cells, sizeMap, percentile, gridSizeKm = 1, minCellsForCapping = 3) {
+    // Group cells by grid
+    const grids = groupCellsByGrid(cells, gridSizeKm);
+    // Calculate percentile cap for each grid
+    const gridCaps = new Map();
+    for (const [gridKey, gridCells] of grids) {
+        // Get sizes for all sites in this grid
+        const siteSizes = new Map();
+        for (const cell of gridCells) {
+            const size = sizeMap.get(cell.siteId);
+            if (size !== undefined) {
+                siteSizes.set(cell.siteId, size);
+            }
+        }
+        const uniqueSizes = Array.from(siteSizes.values());
+        // Only apply capping if grid has enough cells
+        if (uniqueSizes.length >= minCellsForCapping) {
+            const cap = calculatePercentile(uniqueSizes, percentile);
+            gridCaps.set(gridKey, cap);
+        }
+        else {
+            // For small grids, use max size (no capping)
+            gridCaps.set(gridKey, Math.max(...uniqueSizes, 0));
+        }
+    }
+    // Apply caps to each site
+    const cappedSizes = new Map();
+    const sitesProcessed = new Set();
+    for (const cell of cells) {
+        // Only process each site once
+        if (sitesProcessed.has(cell.siteId))
+            continue;
+        sitesProcessed.add(cell.siteId);
+        const originalSize = sizeMap.get(cell.siteId);
+        if (originalSize === undefined)
+            continue;
+        const gridKey = getGridKey(cell.longitude, cell.latitude, gridSizeKm);
+        const cap = gridCaps.get(gridKey) ?? originalSize;
+        // Apply cap (take minimum)
+        cappedSizes.set(cell.siteId, Math.min(originalSize, cap));
+    }
+    return cappedSizes;
+}
+/**
+ * Get statistics about grid-based capping
+ * @param originalSizes Map of original sizes
+ * @param cappedSizes Map of capped sizes
+ * @returns Object with statistics
+ */
+export function getGridCappingStats(originalSizes, cappedSizes) {
+    let totalSites = 0;
+    let cappedSites = 0;
+    let totalReduction = 0;
+    for (const [siteId, originalSize] of originalSizes) {
+        const cappedSize = cappedSizes.get(siteId);
+        if (cappedSize === undefined)
+            continue;
+        totalSites++;
+        if (cappedSize < originalSize) {
+            cappedSites++;
+            totalReduction += originalSize - cappedSize;
+        }
+    }
+    return {
+        totalSites,
+        cappedSites,
+        cappedPercentage: totalSites > 0 ? (cappedSites / totalSites) * 100 : 0,
+        avgReduction: cappedSites > 0 ? totalReduction / cappedSites : 0
+    };
+}

package/dist/map-v3/features/cells/logic/site-distance.d.ts

@@ -26,9 +26,11 @@ export declare function groupBySite(cells: Cell[]): Map<string, Cell[]>;
 export declare function extractSiteLocations(cells: Cell[]): Map<string, [number, number]>;
 /**
  * Compute nearest neighbor distance for a single site
+ * Can average multiple neighbors for better density estimation
  * @param siteId Site to compute distance for
  * @param siteLocation Location of the site
  * @param allSiteLocations Map of all site locations
- * @returns Distance to nearest neighbor in meters, or Infinity if no neighbors
+ * @param neighborCount Number of closest neighbors to average (default: 5)
+ * @returns Average distance to N nearest neighbors in meters, or Infinity if no neighbors
  */
-export declare function computeNearestNeighbor(siteId: string, siteLocation: [number, number], allSiteLocations: Map<string, [number, number]>): number;
+export declare function computeNearestNeighbor(siteId: string, siteLocation: [number, number], allSiteLocations: Map<string, [number, number]>, neighborCount?: number): number;

package/dist/map-v3/features/cells/logic/site-distance.js

@@ -54,18 +54,26 @@ export function extractSiteLocations(cells) {
 }
 /**
  * Compute nearest neighbor distance for a single site
+ * Can average multiple neighbors for better density estimation
  * @param siteId Site to compute distance for
  * @param siteLocation Location of the site
  * @param allSiteLocations Map of all site locations
- * @returns Distance to nearest neighbor in meters, or Infinity if no neighbors
+ * @param neighborCount Number of closest neighbors to average (default: 5)
+ * @returns Average distance to N nearest neighbors in meters, or Infinity if no neighbors
  */
-export function computeNearestNeighbor(siteId, siteLocation, allSiteLocations) {
-    let minDist = Infinity;
+export function computeNearestNeighbor(siteId, siteLocation, allSiteLocations, neighborCount = 5) {
+    const distances = [];
     for (const [otherId, otherLoc] of allSiteLocations) {
         if (siteId === otherId)
             continue;
         const dist = haversineDistance(siteLocation, otherLoc);
-        minDist = Math.min(minDist, dist);
+        distances.push(dist);
     }
-    return minDist;
+    if (distances.length === 0)
+        return Infinity;
+    // Sort distances and take N closest
+    distances.sort((a, b) => a - b);
+    const closestN = distances.slice(0, Math.min(neighborCount, distances.length));
+    // Return average of closest neighbors
+    return closestN.reduce((sum, d) => sum + d, 0) / closestN.length;
 }

package/dist/map-v3/features/cells/stores/cell.data.svelte.d.ts

@@ -1,11 +1,17 @@
 import type { Cell } from '../types';
 import { SiteDistanceStore } from './site.distance.svelte';
+import type { CellDisplayStore } from './cell.display.svelte';
 export declare class CellDataStore {
     rawCells: Cell[];
     filterOnAir: boolean;
     siteDistanceStore: SiteDistanceStore;
-    constructor();
+    displayStore?: CellDisplayStore;
+    constructor(displayStore?: CellDisplayStore);
     setCells(cells: Cell[]): void;
     get filteredCells(): Cell[];
 }
-export declare function createCellDataStore(): CellDataStore;
+/**
+ * Factory function to create a new CellDataStore
+ * @param displayStore Optional display store for auto-size settings
+ */
+export declare function createCellDataStore(displayStore?: CellDisplayStore): CellDataStore;

package/dist/map-v3/features/cells/stores/cell.data.svelte.js

@@ -4,13 +4,21 @@ export class CellDataStore {
     filterOnAir = $state(false);
     // Internal site distance store for auto-sizing
     siteDistanceStore;
-    constructor() {
+    // Reference to display store for auto-size settings
+    displayStore;
+    constructor(displayStore) {
         this.siteDistanceStore = new SiteDistanceStore();
+        this.displayStore = displayStore;
     }
     setCells(cells) {
         this.rawCells = cells;
         // Automatically update site distances when cells are loaded
-        this.siteDistanceStore.updateDistances(cells);
+        // Pass auto-size and grid capping settings from displayStore
+        const neighborCount = this.displayStore?.autoSizeNeighborCount ?? 5;
+        const useGridCapping = this.displayStore?.useGridCapping ?? true;
+        const gridCapPercentile = this.displayStore?.gridCapPercentile ?? 80;
+        const gridSizeKm = this.displayStore?.gridSizeKm ?? 1;
+        this.siteDistanceStore.updateDistances(cells, neighborCount, useGridCapping, gridCapPercentile, gridSizeKm);
     }
     get filteredCells() {
         if (!this.filterOnAir)
@@ -18,6 +26,10 @@ export class CellDataStore {
         return this.rawCells.filter(c => c.status === 'On_Air');
     }
 }
-export function createCellDataStore() {
-    return new CellDataStore();
+/**
+ * Factory function to create a new CellDataStore
+ * @param displayStore Optional display store for auto-size settings
+ */
+export function createCellDataStore(displayStore) {
+    return new CellDataStore(displayStore);
 }

package/dist/map-v3/features/cells/stores/cell.display.svelte.d.ts

@@ -9,6 +9,11 @@ export declare class CellDisplayStore {
     layerGrouping: LayerGroupingPreset;
     useAutoSize: boolean;
     autoSizeMode: AutoSizeMode;
+    autoSizeNeighborCount: number;
+    autoSizeMultiplier: number;
+    useGridCapping: boolean;
+    gridCapPercentile: number;
+    gridSizeKm: number;
     level1: CellGroupingField;
     level2: CellGroupingField;
     currentZIndex: Record<string, number>;

package/dist/map-v3/features/cells/stores/cell.display.svelte.js

@@ -11,6 +11,12 @@ export class CellDisplayStore {
     // Auto-size settings
     useAutoSize = $state(false);
     autoSizeMode = $state('logarithmic');
+    autoSizeNeighborCount = $state(5); // Number of neighbors to average for density
+    autoSizeMultiplier = $state(1.0); // Scale factor for auto-size results (0.3 - 2.0)
+    // Grid-based outlier capping
+    useGridCapping = $state(true); // Enable grid-based outlier removal
+    gridCapPercentile = $state(80); // Percentile for capping (70-95)
+    gridSizeKm = $state(1); // Grid size in kilometers
     // Grouping
     level1 = $state('tech');
     level2 = $state('fband');
@@ -40,6 +46,11 @@ export class CellDisplayStore {
                     this.layerGrouping = parsed.layerGrouping ?? 'frequency';
                     this.useAutoSize = parsed.useAutoSize ?? false;
                     this.autoSizeMode = parsed.autoSizeMode ?? 'logarithmic';
+                    this.autoSizeNeighborCount = parsed.autoSizeNeighborCount ?? 5;
+                    this.autoSizeMultiplier = parsed.autoSizeMultiplier ?? 1.0;
+                    this.useGridCapping = parsed.useGridCapping ?? true;
+                    this.gridCapPercentile = parsed.gridCapPercentile ?? 80;
+                    this.gridSizeKm = parsed.gridSizeKm ?? 1;
                     this.level1 = parsed.level1 ?? 'tech';
                     this.level2 = parsed.level2 ?? 'fband';
                     this.labelPixelDistance = parsed.labelPixelDistance ?? 60;
@@ -64,6 +75,11 @@ export class CellDisplayStore {
                     layerGrouping: this.layerGrouping,
                     useAutoSize: this.useAutoSize,
                     autoSizeMode: this.autoSizeMode,
+                    autoSizeNeighborCount: this.autoSizeNeighborCount,
+                    autoSizeMultiplier: this.autoSizeMultiplier,
+                    useGridCapping: this.useGridCapping,
+                    gridCapPercentile: this.gridCapPercentile,
+                    gridSizeKm: this.gridSizeKm,
                     level1: this.level1,
                     level2: this.level2,
                     labelPixelDistance: this.labelPixelDistance,

package/dist/map-v3/features/cells/stores/site.distance.svelte.d.ts

@@ -8,6 +8,7 @@ import type { Cell } from '../types';
 export declare class SiteDistanceStore {
     key: string;
     distances: Map<string, number>;
+    cappedSizes: Map<string, number>;
     computedSites: Set<string>;
     lastComputeTime: number;
     computedCount: number;
@@ -15,14 +16,20 @@ export declare class SiteDistanceStore {
     /**
      * Incrementally update distances for new sites
      * Only computes distances for sites not in cache
+     * @param cells Array of cells to compute distances for
+     * @param neighborCount Number of neighbors to average for density calculation
+     * @param useGridCapping Whether to apply grid-based outlier capping
+     * @param gridCapPercentile Percentile for grid capping (70-95)
+     * @param gridSizeKm Grid size in kilometers
      */
-    updateDistances(cells: Cell[]): void;
+    updateDistances(cells: Cell[], neighborCount?: number, useGridCapping?: boolean, gridCapPercentile?: number, gridSizeKm?: number): void;
     /**
      * Update existing sites if needed (when no new sites but data might have changed)
      */
     private updateExistingSitesIfNeeded;
     /**
      * Get distance for a site, with fallback
+     * Returns capped size if grid capping was applied, otherwise original
      */
     getDistance(siteId: string, fallback?: number): number;
     /**

package/dist/map-v3/features/cells/stores/site.distance.svelte.js

@@ -6,10 +6,13 @@
  */
 import { browser } from '$app/environment';
 import { extractSiteLocations, computeNearestNeighbor, haversineDistance } from '../logic/site-distance';
+import { computeGridBasedSizeCaps, getGridCappingStats } from '../logic/grid-density';
 export class SiteDistanceStore {
     key = 'map-v3-site-distances';
-    // Cached nearest neighbor distances
+    // Cached nearest neighbor distances (original calculated sizes)
     distances = $state(new Map());
+    // Grid-capped sizes (after outlier removal)
+    cappedSizes = $state(new Map());
     // Track which sites have been computed
     computedSites = $state(new Set());
     // Performance tracking
@@ -23,8 +26,13 @@ export class SiteDistanceStore {
     /**
      * Incrementally update distances for new sites
      * Only computes distances for sites not in cache
+     * @param cells Array of cells to compute distances for
+     * @param neighborCount Number of neighbors to average for density calculation
+     * @param useGridCapping Whether to apply grid-based outlier capping
+     * @param gridCapPercentile Percentile for grid capping (70-95)
+     * @param gridSizeKm Grid size in kilometers
      */
-    updateDistances(cells) {
+    updateDistances(cells, neighborCount = 5, useGridCapping = true, gridCapPercentile = 80, gridSizeKm = 1) {
         if (!cells || cells.length === 0)
             return;
         const startTime = performance.now();
@@ -37,11 +45,11 @@ export class SiteDistanceStore {
             this.updateExistingSitesIfNeeded(siteLocations);
             return;
         }
-        console.log(`[SiteDistance] Computing distances for ${newSites.length} new sites`);
+        console.log(`[SiteDistance] Computing distances for ${newSites.length} new sites (${neighborCount} neighbors)`);
         // Compute distances for NEW sites
         for (const siteId of newSites) {
             const location = siteLocations.get(siteId);
-            const nearestDist = computeNearestNeighbor(siteId, location, siteLocations);
+            const nearestDist = computeNearestNeighbor(siteId, location, siteLocations, neighborCount);
             this.distances.set(siteId, nearestDist);
             this.computedSites.add(siteId);
         }
@@ -49,15 +57,19 @@ export class SiteDistanceStore {
         for (const [existingId, existingLoc] of siteLocations) {
             if (newSites.includes(existingId))
                 continue; // Skip new sites
-            let currentMin = this.distances.get(existingId) || Infinity;
-            for (const newId of newSites) {
-                const newLoc = siteLocations.get(newId);
-                const dist = haversineDistance(existingLoc, newLoc);
-                currentMin = Math.min(currentMin, dist);
-            }
-            if (currentMin < (this.distances.get(existingId) || Infinity)) {
-                this.distances.set(existingId, currentMin);
-            }
+            // Recalculate with new sites present
+            const updatedDist = computeNearestNeighbor(existingId, existingLoc, siteLocations, neighborCount);
+            this.distances.set(existingId, updatedDist);
+        }
+        // Apply grid-based capping if enabled
+        if (useGridCapping) {
+            this.cappedSizes = computeGridBasedSizeCaps(cells, this.distances, gridCapPercentile, gridSizeKm);
+            const stats = getGridCappingStats(this.distances, this.cappedSizes);
+            console.log(`[SiteDistance] Grid capping: ${stats.cappedSites}/${stats.totalSites} sites capped (${stats.cappedPercentage.toFixed(1)}%), avg reduction: ${stats.avgReduction.toFixed(1)}m`);
+        }
+        else {
+            // No capping - capped sizes = original sizes
+            this.cappedSizes = new Map(this.distances);
         }
         const endTime = performance.now();
         this.lastComputeTime = endTime - startTime;
@@ -86,15 +98,17 @@ export class SiteDistanceStore {
     }
     /**
      * Get distance for a site, with fallback
+     * Returns capped size if grid capping was applied, otherwise original
      */
     getDistance(siteId, fallback = 500) {
-        return this.distances.get(siteId) ?? fallback;
+        return this.cappedSizes.get(siteId) ?? this.distances.get(siteId) ?? fallback;
     }
     /**
      * Clear all cached distances (useful for testing or data refresh)
      */
     clear() {
         this.distances.clear();
+        this.cappedSizes.clear();
         this.computedSites.clear();
         this.lastComputeTime = 0;
         this.computedCount = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smartnet360/svelte-components",
-	"version": "0.0.92",
+	"version": "0.0.94",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",