@smartnet360/svelte-components 0.0.51 → 0.0.54

package/dist/map/stores/mapStore.js

@@ -0,0 +1,10 @@
+/**
+ * Store factory and utilities for Mapbox instance
+ */
+import { writable } from 'svelte/store';
+/**
+ * Creates a writable store for the Mapbox instance
+ */
+export function createMapStore() {
+    return writable(null);
+}

package/dist/map/types.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Core types for Mapbox cellular visualization components
+ */
+import type { Writable } from 'svelte/store';
+/** Context key for the Mapbox instance store */
+export declare const MAP_CONTEXT_KEY: unique symbol;
+/** Context key for the cell data stores */
+export declare const CELL_DATA_CONTEXT_KEY: unique symbol;
+/**
+ * Represents a cellular site/tower location
+ */
+export interface Site {
+    /** Unique identifier for the site */
+    id: string;
+    /** Human-readable site name */
+    name: string;
+    /** Latitude (WGS84) */
+    latitude: number;
+    /** Longitude (WGS84) */
+    longitude: number;
+    /** Frequency bands */
+    fbands?: string[];
+    /** Technology (e.g., '4G', '5G', 'LTE') */
+    technology: string;
+    /** Additional properties */
+    properties: Record<string, any>;
+    /** Array of cell names at this site */
+    cellNames: string[];
+    /** Source or owning organization (e.g. 'Vodafone', 'France Telecom') */
+    provider: string;
+    /** Sub-classification used for TreeView grouping for level2 grouping */
+    featureGroup: string;
+}
+/**
+ * Represents a cellular sector/cell with coverage area
+ */
+export interface Cell {
+    /** Unique identifier for the cell */
+    id: string;
+    /** ID of the parent site */
+    siteId: string;
+    /** Sector number (e.g., 1, 2, 3) */
+    sector?: number;
+    /** Azimuth/bearing in degrees (0-360, where 0 is North) */
+    azimuth: number;
+    /** Beamwidth/aperture in degrees (e.g., 65, 120) */
+    beamwidth: number;
+    /** Coverage radius in meters (default: 500) */
+    radius?: number;
+    /** Optional additional properties (band, technology, etc.) */
+    properties?: Record<string, unknown>;
+}
+/**
+ * User interaction state (selection, hover)
+ */
+export interface InteractionState {
+    /** Currently selected site ID */
+    selectedSiteId: string | null;
+    /** Currently selected cell ID */
+    selectedCellId: string | null;
+    /** Currently hovered site ID */
+    hoveredSiteId: string | null;
+    /** Currently hovered cell ID */
+    hoveredCellId: string | null;
+}
+/**
+ * Map instance store provided by MapboxProvider
+ */
+export type MapStore = Writable<mapboxgl.Map | null>;
+/**
+ * Cell data context stores provided by CellDataProvider
+ */
+export interface CellDataContext {
+    /** Store containing all sites */
+    sites: Writable<Site[]>;
+    /** Store containing all cells */
+    cells: Writable<Cell[]>;
+    /** Store for selected site ID */
+    selectedSiteId: Writable<string | null>;
+    /** Store for selected cell ID */
+    selectedCellId: Writable<string | null>;
+    /** Store for hovered site ID */
+    hoveredSiteId: Writable<string | null>;
+    /** Store for hovered cell ID */
+    hoveredCellId: Writable<string | null>;
+}
+/**
+ * GeoJSON Point Feature for a site
+ */
+export interface SiteFeature {
+    type: 'Feature';
+    geometry: {
+        type: 'Point';
+        coordinates: [number, number];
+    };
+    properties: Site;
+}
+/**
+ * GeoJSON Polygon Feature for a cell sector
+ */
+export interface CellFeature {
+    type: 'Feature';
+    geometry: {
+        type: 'Polygon';
+        coordinates: number[][][];
+    };
+    properties: Cell;
+}
+/**
+ * GeoJSON FeatureCollection
+ */
+export interface FeatureCollection<T> {
+    type: 'FeatureCollection';
+    features: T[];
+}

package/dist/map/types.js

@@ -0,0 +1,10 @@
+/**
+ * Core types for Mapbox cellular visualization components
+ */
+// ============================================================================
+// Context Keys
+// ============================================================================
+/** Context key for the Mapbox instance store */
+export const MAP_CONTEXT_KEY = Symbol('mapbox-instance');
+/** Context key for the cell data stores */
+export const CELL_DATA_CONTEXT_KEY = Symbol('cell-data');

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

@@ -0,0 +1,20 @@
+/**
+ * GeoJSON conversion utilities for sites and cells
+ */
+import type { Site, Cell, SiteFeature, CellFeature, FeatureCollection } from '../types';
+/**
+ * Converts an array of sites to a GeoJSON FeatureCollection
+ */
+export declare function sitesToGeoJSON(sites: Site[]): FeatureCollection<SiteFeature>;
+/**
+ * Converts an array of cells to a GeoJSON FeatureCollection of polygons
+ */
+export declare function cellsToGeoJSON(cells: Cell[], sites: Site[], defaultRadius?: number): FeatureCollection<CellFeature>;
+/**
+ * Converts a single site to a GeoJSON Feature
+ */
+export declare function siteToFeature(site: Site): SiteFeature;
+/**
+ * Converts a single cell to a GeoJSON Feature (requires parent site for location)
+ */
+export declare function cellToFeature(cell: Cell, site: Site, defaultRadius?: number): CellFeature | null;

package/dist/map/utils/geojson.js

@@ -0,0 +1,78 @@
+/**
+ * GeoJSON conversion utilities for sites and cells
+ */
+import { createSectorPolygon } from './math';
+/**
+ * Converts an array of sites to a GeoJSON FeatureCollection
+ */
+export function sitesToGeoJSON(sites) {
+    const features = sites.map((site) => ({
+        type: 'Feature',
+        geometry: {
+            type: 'Point',
+            coordinates: [site.longitude, site.latitude]
+        },
+        properties: site
+    }));
+    return {
+        type: 'FeatureCollection',
+        features
+    };
+}
+/**
+ * Converts an array of cells to a GeoJSON FeatureCollection of polygons
+ */
+export function cellsToGeoJSON(cells, sites, defaultRadius = 500) {
+    // Create a map for fast site lookup
+    const siteMap = new Map(sites.map((site) => [site.id, site]));
+    const features = [];
+    for (const cell of cells) {
+        const site = siteMap.get(cell.siteId);
+        if (!site) {
+            console.warn(`Cell ${cell.id} references unknown site ${cell.siteId}`);
+            continue;
+        }
+        const radius = cell.radius ?? defaultRadius;
+        const coordinates = createSectorPolygon(site.longitude, site.latitude, cell.azimuth, cell.beamwidth, radius);
+        features.push({
+            type: 'Feature',
+            geometry: {
+                type: 'Polygon',
+                coordinates: [coordinates]
+            },
+            properties: cell
+        });
+    }
+    return {
+        type: 'FeatureCollection',
+        features
+    };
+}
+/**
+ * Converts a single site to a GeoJSON Feature
+ */
+export function siteToFeature(site) {
+    return {
+        type: 'Feature',
+        geometry: {
+            type: 'Point',
+            coordinates: [site.longitude, site.latitude]
+        },
+        properties: site
+    };
+}
+/**
+ * Converts a single cell to a GeoJSON Feature (requires parent site for location)
+ */
+export function cellToFeature(cell, site, defaultRadius = 500) {
+    const radius = cell.radius ?? defaultRadius;
+    const coordinates = createSectorPolygon(site.longitude, site.latitude, cell.azimuth, cell.beamwidth, radius);
+    return {
+        type: 'Feature',
+        geometry: {
+            type: 'Polygon',
+            coordinates: [coordinates]
+        },
+        properties: cell
+    };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Mapbox GL JS helper utilities for layer and source management
+ */
+/**
+ * Safely adds a source to the map if it doesn't already exist
+ */
+export declare function addSourceIfMissing(map: mapboxgl.Map, sourceId: string, sourceSpec: mapboxgl.AnySourceData): void;
+/**
+ * Safely removes a source from the map if it exists
+ */
+export declare function removeSourceIfExists(map: mapboxgl.Map, sourceId: string): void;
+/**
+ * Safely adds a layer to the map if it doesn't already exist
+ */
+export declare function addLayerIfMissing(map: mapboxgl.Map, layer: mapboxgl.AnyLayer, beforeId?: string): void;
+/**
+ * Safely removes a layer from the map if it exists
+ */
+export declare function removeLayerIfExists(map: mapboxgl.Map, layerId: string): void;
+/**
+ * Updates GeoJSON source data if the source exists
+ */
+export declare function updateGeoJSONSource(map: mapboxgl.Map, sourceId: string, data: GeoJSON.FeatureCollection | GeoJSON.Feature): void;
+/**
+ * Removes a layer and its associated source
+ */
+export declare function removeLayerAndSource(map: mapboxgl.Map, layerId: string, sourceId: string): void;
+/**
+ * Checks if the map style is loaded
+ */
+export declare function isStyleLoaded(map: mapboxgl.Map): boolean;
+/**
+ * Waits for the map style to be loaded
+ */
+export declare function waitForStyleLoad(map: mapboxgl.Map): Promise<void>;
+/**
+ * Sets a feature state on a source
+ */
+export declare function setFeatureState(map: mapboxgl.Map, sourceId: string, featureId: string | number, state: Record<string, unknown>): void;
+/**
+ * Removes a feature state from a source
+ */
+export declare function removeFeatureState(map: mapboxgl.Map, sourceId: string, featureId: string | number, key?: string): void;
+/**
+ * Generates a unique layer ID with a namespace prefix
+ */
+export declare function generateLayerId(namespace: string, layerName: string): string;
+/**
+ * Generates a unique source ID with a namespace prefix
+ */
+export declare function generateSourceId(namespace: string, sourceName: string): string;

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;