@smartnet360/svelte-components 0.0.51 → 0.0.53

package/dist/map/utils/mapboxHelpers.js

@@ -0,0 +1,98 @@
+/**
+ * Mapbox GL JS helper utilities for layer and source management
+ */
+/**
+ * Safely adds a source to the map if it doesn't already exist
+ */
+export function addSourceIfMissing(map, sourceId, sourceSpec) {
+    if (!map.getSource(sourceId)) {
+        map.addSource(sourceId, sourceSpec);
+    }
+}
+/**
+ * Safely removes a source from the map if it exists
+ */
+export function removeSourceIfExists(map, sourceId) {
+    if (map.getSource(sourceId)) {
+        map.removeSource(sourceId);
+    }
+}
+/**
+ * Safely adds a layer to the map if it doesn't already exist
+ */
+export function addLayerIfMissing(map, layer, beforeId) {
+    if (!map.getLayer(layer.id)) {
+        map.addLayer(layer, beforeId);
+    }
+}
+/**
+ * Safely removes a layer from the map if it exists
+ */
+export function removeLayerIfExists(map, layerId) {
+    if (map.getLayer(layerId)) {
+        map.removeLayer(layerId);
+    }
+}
+/**
+ * Updates GeoJSON source data if the source exists
+ */
+export function updateGeoJSONSource(map, sourceId, data) {
+    const source = map.getSource(sourceId);
+    if (source && source.type === 'geojson') {
+        source.setData(data);
+    }
+}
+/**
+ * Removes a layer and its associated source
+ */
+export function removeLayerAndSource(map, layerId, sourceId) {
+    removeLayerIfExists(map, layerId);
+    removeSourceIfExists(map, sourceId);
+}
+/**
+ * Checks if the map style is loaded
+ */
+export function isStyleLoaded(map) {
+    return map.isStyleLoaded();
+}
+/**
+ * Waits for the map style to be loaded
+ */
+export async function waitForStyleLoad(map) {
+    if (isStyleLoaded(map)) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        map.once('styledata', () => resolve());
+    });
+}
+/**
+ * Sets a feature state on a source
+ */
+export function setFeatureState(map, sourceId, featureId, state) {
+    map.setFeatureState({
+        source: sourceId,
+        id: featureId
+    }, state);
+}
+/**
+ * Removes a feature state from a source
+ */
+export function removeFeatureState(map, sourceId, featureId, key) {
+    map.removeFeatureState({
+        source: sourceId,
+        id: featureId
+    }, key);
+}
+/**
+ * Generates a unique layer ID with a namespace prefix
+ */
+export function generateLayerId(namespace, layerName) {
+    return `${namespace}:${layerName}`;
+}
+/**
+ * Generates a unique source ID with a namespace prefix
+ */
+export function generateSourceId(namespace, sourceName) {
+    return `${namespace}:${sourceName}`;
+}

package/dist/map/utils/math.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Mathematical utilities for cellular sector geometry
+ */
+/**
+ * Calculates the destination point given start point, bearing, and distance
+ * Uses Haversine formula
+ *
+ * @param lon - Starting longitude
+ * @param lat - Starting latitude
+ * @param bearing - Bearing in degrees (0 = North, 90 = East)
+ * @param distance - Distance in meters
+ * @returns [lon, lat] of destination point
+ */
+export declare function destinationPoint(lon: number, lat: number, bearing: number, distance: number): [number, number];
+/**
+ * Creates a polygon representing a cellular sector
+ *
+ * @param centerLon - Center point longitude
+ * @param centerLat - Center point latitude
+ * @param azimuth - Sector azimuth/bearing in degrees (0-360, where 0 is North)
+ * @param beamwidth - Sector beamwidth in degrees (e.g., 65, 120)
+ * @param radius - Sector radius in meters
+ * @param arcPoints - Number of points to use for the arc (default: 32)
+ * @returns Array of [lon, lat] coordinates forming a closed polygon
+ */
+export declare function createSectorPolygon(centerLon: number, centerLat: number, azimuth: number, beamwidth: number, radius: number, arcPoints?: number): [number, number][];
+/**
+ * Creates a circle polygon (360-degree sector)
+ *
+ * @param centerLon - Center point longitude
+ * @param centerLat - Center point latitude
+ * @param radius - Circle radius in meters
+ * @param points - Number of points to use for the circle (default: 64)
+ * @returns Array of [lon, lat] coordinates forming a closed polygon
+ */
+export declare function createCirclePolygon(centerLon: number, centerLat: number, radius: number, points?: number): [number, number][];
+/**
+ * Normalizes an azimuth to 0-360 range
+ */
+export declare function normalizeAzimuth(azimuth: number): number;

package/dist/map/utils/math.js

@@ -0,0 +1,95 @@
+/**
+ * Mathematical utilities for cellular sector geometry
+ */
+/**
+ * Converts degrees to radians
+ */
+function toRadians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+/**
+ * Converts radians to degrees
+ */
+function toDegrees(radians) {
+    return (radians * 180) / Math.PI;
+}
+/**
+ * Calculates the destination point given start point, bearing, and distance
+ * Uses Haversine formula
+ *
+ * @param lon - Starting longitude
+ * @param lat - Starting latitude
+ * @param bearing - Bearing in degrees (0 = North, 90 = East)
+ * @param distance - Distance in meters
+ * @returns [lon, lat] of destination point
+ */
+export function destinationPoint(lon, lat, bearing, distance) {
+    const R = 6371e3; // Earth radius in meters
+    const δ = distance / R; // Angular distance
+    const θ = toRadians(bearing);
+    const φ1 = toRadians(lat);
+    const λ1 = toRadians(lon);
+    const φ2 = Math.asin(Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ));
+    const λ2 = λ1 +
+        Math.atan2(Math.sin(θ) * Math.sin(δ) * Math.cos(φ1), Math.cos(δ) - Math.sin(φ1) * Math.sin(φ2));
+    return [toDegrees(λ2), toDegrees(φ2)];
+}
+/**
+ * Creates a polygon representing a cellular sector
+ *
+ * @param centerLon - Center point longitude
+ * @param centerLat - Center point latitude
+ * @param azimuth - Sector azimuth/bearing in degrees (0-360, where 0 is North)
+ * @param beamwidth - Sector beamwidth in degrees (e.g., 65, 120)
+ * @param radius - Sector radius in meters
+ * @param arcPoints - Number of points to use for the arc (default: 32)
+ * @returns Array of [lon, lat] coordinates forming a closed polygon
+ */
+export function createSectorPolygon(centerLon, centerLat, azimuth, beamwidth, radius, arcPoints = 32) {
+    const coordinates = [];
+    // Start at the center point
+    coordinates.push([centerLon, centerLat]);
+    // Calculate start and end bearings
+    const startBearing = azimuth - beamwidth / 2;
+    const endBearing = azimuth + beamwidth / 2;
+    // Generate arc points
+    const angleStep = beamwidth / (arcPoints - 1);
+    for (let i = 0; i < arcPoints; i++) {
+        const bearing = startBearing + angleStep * i;
+        const point = destinationPoint(centerLon, centerLat, bearing, radius);
+        coordinates.push(point);
+    }
+    // Close the polygon by returning to center
+    coordinates.push([centerLon, centerLat]);
+    return coordinates;
+}
+/**
+ * Creates a circle polygon (360-degree sector)
+ *
+ * @param centerLon - Center point longitude
+ * @param centerLat - Center point latitude
+ * @param radius - Circle radius in meters
+ * @param points - Number of points to use for the circle (default: 64)
+ * @returns Array of [lon, lat] coordinates forming a closed polygon
+ */
+export function createCirclePolygon(centerLon, centerLat, radius, points = 64) {
+    const coordinates = [];
+    const angleStep = 360 / points;
+    for (let i = 0; i < points; i++) {
+        const bearing = angleStep * i;
+        const point = destinationPoint(centerLon, centerLat, bearing, radius);
+        coordinates.push(point);
+    }
+    // Close the polygon
+    coordinates.push(coordinates[0]);
+    return coordinates;
+}
+/**
+ * Normalizes an azimuth to 0-360 range
+ */
+export function normalizeAzimuth(azimuth) {
+    let normalized = azimuth % 360;
+    if (normalized < 0)
+        normalized += 360;
+    return normalized;
+}

package/dist/map/utils/siteTreeUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Utilities for building and managing site filter tree
+ */
+import type { Site } from '../types';
+import type { TreeNode } from '../../core/TreeView/tree.model';
+/**
+ * Builds a hierarchical tree from flat site array
+ * Structure: All Sites -> Provider -> Feature Group
+ */
+export declare function buildSiteTree(sites: Site[]): TreeNode;
+/**
+ * Filters sites based on checked tree paths
+ */
+export declare function getFilteredSites(checkedPaths: string[], allSites: Site[]): Site[];
+/**
+ * Saves tree checked paths to localStorage
+ */
+export declare function saveTreeState(checkedPaths: string[]): void;
+/**
+ * Loads tree state from localStorage
+ * Returns map of node IDs to checked state
+ */
+export declare function loadTreeState(): Record<string, boolean>;
+/**
+ * Clears saved tree state
+ */
+export declare function clearTreeState(): void;

package/dist/map/utils/siteTreeUtils.js

@@ -0,0 +1,164 @@
+/**
+ * Utilities for building and managing site filter tree
+ */
+const STORAGE_PREFIX = 'cellular:siteFilter';
+/**
+ * Builds a hierarchical tree from flat site array
+ * Structure: All Sites -> Provider -> Feature Group
+ */
+export function buildSiteTree(sites) {
+    // Group sites by provider, then by feature group
+    const providerGroups = new Map();
+    sites.forEach((site) => {
+        if (!providerGroups.has(site.provider)) {
+            providerGroups.set(site.provider, new Map());
+        }
+        const featureGroups = providerGroups.get(site.provider);
+        if (!featureGroups.has(site.featureGroup)) {
+            featureGroups.set(site.featureGroup, []);
+        }
+        featureGroups.get(site.featureGroup).push(site);
+    });
+    // Load saved state from localStorage
+    const savedState = loadTreeState();
+    // Build tree structure
+    const children = [];
+    // Sort providers alphabetically
+    const sortedProviders = Array.from(providerGroups.keys()).sort();
+    sortedProviders.forEach((provider) => {
+        const featureGroups = providerGroups.get(provider);
+        const providerChildren = [];
+        // Sort feature groups alphabetically
+        const sortedFeatureGroups = Array.from(featureGroups.keys()).sort();
+        sortedFeatureGroups.forEach((featureGroup) => {
+            const groupSites = featureGroups.get(featureGroup);
+            const nodeId = `${provider}:${featureGroup}`;
+            providerChildren.push({
+                id: nodeId,
+                label: `${featureGroup} (${groupSites.length})`,
+                defaultChecked: savedState[nodeId] ?? true, // Default checked
+                children: [],
+                metadata: {
+                    type: 'featureGroup',
+                    provider,
+                    featureGroup,
+                    siteIds: groupSites.map((s) => s.id)
+                }
+            });
+        });
+        const providerId = provider;
+        children.push({
+            id: providerId,
+            label: `${provider} (${Array.from(featureGroups.values()).flat().length})`,
+            defaultChecked: savedState[providerId] ?? true, // Default checked
+            children: providerChildren,
+            metadata: {
+                type: 'provider',
+                provider
+            }
+        });
+    });
+    // Root node
+    return {
+        id: 'all-sites',
+        label: `All Sites (${sites.length})`,
+        defaultChecked: savedState['all-sites'] ?? true, // Default checked
+        children,
+        metadata: {
+            type: 'root'
+        }
+    };
+}
+/**
+ * Filters sites based on checked tree paths
+ */
+export function getFilteredSites(checkedPaths, allSites) {
+    console.log('getFilteredSites called with paths:', checkedPaths);
+    const checkedGroups = new Set();
+    const checkedProviders = new Set();
+    checkedPaths.forEach((path) => {
+        // TreeView adds parent prefixes, so paths look like:
+        // "all-sites:Verizon:Verizon:Urban Macro"
+        // We need to extract the actual provider:featureGroup
+        // Split by separator
+        const parts = path.split(':');
+        // Remove "all-sites" prefix if present
+        const filteredParts = parts.filter(p => p !== 'all-sites');
+        if (filteredParts.length === 3) {
+            // Format: [provider, provider, featureGroup]
+            // The provider is duplicated, extract it as provider:featureGroup
+            const provider = filteredParts[1];
+            const featureGroup = filteredParts[2];
+            checkedGroups.add(`${provider}:${featureGroup}`);
+        }
+        else if (filteredParts.length === 1) {
+            // Just a provider
+            checkedProviders.add(filteredParts[0]);
+        }
+    });
+    console.log('Checked groups:', Array.from(checkedGroups));
+    console.log('Checked providers:', Array.from(checkedProviders));
+    // If "all-sites" is checked and it's the only thing, return all
+    if (checkedPaths.includes('all-sites') && checkedGroups.size === 0 && checkedProviders.size === 0) {
+        console.log('All sites root checked, returning all');
+        return allSites;
+    }
+    // If nothing is checked, return empty
+    if (checkedGroups.size === 0 && checkedProviders.size === 0) {
+        console.log('Nothing checked, returning empty');
+        return [];
+    }
+    // Filter sites based on checked groups or providers
+    const filtered = allSites.filter((site) => {
+        const key = `${site.provider}:${site.featureGroup}`;
+        // Include if the specific group is checked OR if the provider is checked
+        const included = checkedGroups.has(key) || checkedProviders.has(site.provider);
+        return included;
+    });
+    console.log('Filtered:', filtered.length, 'of', allSites.length, 'sites');
+    return filtered;
+}
+/**
+ * Saves tree checked paths to localStorage
+ */
+export function saveTreeState(checkedPaths) {
+    try {
+        localStorage.setItem(STORAGE_PREFIX, JSON.stringify(checkedPaths));
+    }
+    catch (error) {
+        console.warn('Failed to save tree state to localStorage:', error);
+    }
+}
+/**
+ * Loads tree state from localStorage
+ * Returns map of node IDs to checked state
+ */
+export function loadTreeState() {
+    try {
+        const saved = localStorage.getItem(STORAGE_PREFIX);
+        if (saved) {
+            const paths = JSON.parse(saved);
+            // Convert paths to map for easier lookup during tree building
+            const stateMap = {};
+            paths.forEach((path) => {
+                stateMap[path] = true;
+            });
+            return stateMap;
+        }
+    }
+    catch (error) {
+        console.warn('Failed to load tree state from localStorage:', error);
+    }
+    return {};
+}
+/**
+ * Clears saved tree state
+ */
+export function clearTreeState() {
+    try {
+        localStorage.removeItem(STORAGE_PREFIX);
+    }
+    catch (error) {
+        console.warn('Failed to clear tree state from localStorage:', error);
+    }
+}

package/package.json

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