@smartnet360/svelte-components 0.0.102 → 0.0.103

package/dist/core/CoverageMap/data/AntennaStore.js

@@ -0,0 +1,327 @@
+/**
+ * Antenna Store
+ *
+ * This module manages antenna pattern data for the coverage calculator.
+ * It integrates with the existing antenna pattern database and provides
+ * a clean API for:
+ * - Loading antenna data
+ * - Caching frequently used antennas
+ * - Converting database format to calculation format
+ * - Managing antenna library
+ *
+ * Integration with existing system:
+ * - Reuses antenna-pattern database (Dexie)
+ * - Compatible with MSI file format
+ * - Shares antenna data across components
+ */
+import { db as antennaDB } from '../../../apps/antenna-pattern/db';
+import { dBdTodBi } from '../utils/rfUtils';
+// ============================================================================
+// ANTENNA STORE CLASS
+// ============================================================================
+/**
+ * Antenna Store - Manages antenna pattern data
+ *
+ * Provides caching and convenience methods for accessing
+ * antenna data needed for coverage calculations.
+ *
+ * Features:
+ * - Automatic database connection
+ * - In-memory caching (reduces DB queries)
+ * - Format conversion (DB → AntennaPattern type)
+ * - Search and filtering
+ */
+export class AntennaStore {
+    cache = new Map();
+    initialized = false;
+    /**
+     * Initialize the antenna store
+     *
+     * Checks database connection and loads frequently used antennas.
+     * Call this once before using other methods.
+     *
+     * @returns Promise resolving to true if initialized successfully
+     */
+    async initialize() {
+        try {
+            // Check if database has data
+            const hasData = await antennaDB.hasData();
+            if (!hasData) {
+                console.warn('Antenna database is empty. Load antenna files first.');
+                return false;
+            }
+            this.initialized = true;
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to initialize antenna store:', error);
+            return false;
+        }
+    }
+    /**
+     * Get antenna by name
+     *
+     * Retrieves antenna pattern from database (or cache if available).
+     * Returns null if antenna not found.
+     *
+     * @param name - Antenna name (e.g., "ADU4515R17v06")
+     * @param tilt - Electrical tilt (e.g., "3", "6", "9")
+     * @returns Antenna pattern or null
+     *
+     * @example
+     * const antenna = await store.getAntenna("ADU4515R17v06", "3");
+     * if (antenna) {
+     *   console.log(`Gain: ${antenna.gain_dBd} dBd`);
+     * }
+     */
+    async getAntenna(name, tilt) {
+        // Check cache first
+        const cacheKey = `${name}_${tilt}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        try {
+            // Query database
+            const dbAntenna = await antennaDB.antennas
+                .where({ name, tilt })
+                .first();
+            if (!dbAntenna) {
+                console.warn(`Antenna not found: ${name} with tilt ${tilt}`);
+                return null;
+            }
+            // Convert to AntennaPattern format
+            const antennaPattern = this.convertToAntennaPattern(dbAntenna);
+            // Cache for future use
+            this.cache.set(cacheKey, antennaPattern);
+            return antennaPattern;
+        }
+        catch (error) {
+            console.error(`Error loading antenna ${name}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Get antenna by ID
+     *
+     * @param id - Database ID
+     * @returns Antenna pattern or null
+     */
+    async getAntennaById(id) {
+        try {
+            const dbAntenna = await antennaDB.antennas.get(id);
+            if (!dbAntenna) {
+                return null;
+            }
+            return this.convertToAntennaPattern(dbAntenna);
+        }
+        catch (error) {
+            console.error(`Error loading antenna by ID ${id}:`, error);
+            return null;
+        }
+    }
+    /**
+     * List all available antennas
+     *
+     * Returns a list of antenna models (without tilt variants).
+     * Useful for populating dropdown menus.
+     *
+     * @returns Array of unique antenna names
+     */
+    async listAntennaModels() {
+        try {
+            const allAntennas = await antennaDB.antennas.toArray();
+            // Get unique names
+            const uniqueNames = new Set(allAntennas.map((a) => a.name));
+            return Array.from(uniqueNames).sort();
+        }
+        catch (error) {
+            console.error('Error listing antennas:', error);
+            return [];
+        }
+    }
+    /**
+     * Get available tilts for an antenna model
+     *
+     * @param name - Antenna model name
+     * @returns Array of available tilts (e.g., ["0", "3", "6", "9"])
+     */
+    async getAvailableTilts(name) {
+        try {
+            const antennas = await antennaDB.antennas
+                .where({ name })
+                .toArray();
+            const tilts = antennas
+                .map((a) => a.tilt)
+                .filter((t) => t) // Remove null/undefined
+                .sort((a, b) => parseFloat(a) - parseFloat(b));
+            return Array.from(new Set(tilts)); // Remove duplicates
+        }
+        catch (error) {
+            console.error(`Error getting tilts for ${name}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Search antennas by criteria
+     *
+     * @param criteria - Search criteria
+     * @returns Array of matching antennas
+     *
+     * @example
+     * const antennas = await store.searchAntennas({
+     *   frequencyMin: 1700,
+     *   frequencyMax: 1900,
+     *   gainMin: 15
+     * });
+     */
+    async searchAntennas(criteria) {
+        try {
+            let query = antennaDB.antennas.toCollection();
+            // Apply filters
+            const antennas = await query.toArray();
+            return antennas
+                .filter((a) => {
+                if (criteria.namePattern && !a.name.includes(criteria.namePattern)) {
+                    return false;
+                }
+                if (criteria.frequencyMin && a.frequency < criteria.frequencyMin) {
+                    return false;
+                }
+                if (criteria.frequencyMax && a.frequency > criteria.frequencyMax) {
+                    return false;
+                }
+                if (criteria.gainMin && a.gain_dBd < criteria.gainMin) {
+                    return false;
+                }
+                if (criteria.gainMax && a.gain_dBd > criteria.gainMax) {
+                    return false;
+                }
+                return true;
+            })
+                .map((a) => this.convertToAntennaPattern(a));
+        }
+        catch (error) {
+            console.error('Error searching antennas:', error);
+            return [];
+        }
+    }
+    /**
+     * Clear cache
+     *
+     * Useful if antenna data is updated in database.
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache info
+     */
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            entries: Array.from(this.cache.keys())
+        };
+    }
+    // ========================================================================
+    // PRIVATE HELPER METHODS
+    // ========================================================================
+    /**
+     * Convert database antenna format to AntennaPattern type
+     *
+     * The database stores antennas in one format (from MSI files),
+     * but the coverage calculator needs a specific format.
+     * This function does the conversion.
+     *
+     * @param dbAntenna - Antenna from database
+     * @returns AntennaPattern for coverage calculator
+     */
+    convertToAntennaPattern(dbAntenna) {
+        // Extract available tilts from the database
+        // For now, we'll use the current tilt as the only available tilt
+        // In a full implementation, you'd query all tilts for this model
+        const availableTilts = dbAntenna.tilt ? [dbAntenna.tilt] : ['0'];
+        // Ensure patterns have 360 values
+        const pattern = this.ensurePattern(dbAntenna.pattern);
+        const vertical_pattern = this.ensurePattern(dbAntenna.vertical_pattern);
+        return {
+            name: dbAntenna.name,
+            model: dbAntenna.name,
+            frequency: dbAntenna.frequency,
+            gain_dBd: dbAntenna.gain_dBd,
+            gain_dBi: dBdTodBi(dbAntenna.gain_dBd),
+            pattern,
+            vertical_pattern,
+            availableTilts,
+            // Optional fields
+            beamwidth_horizontal: undefined, // Could calculate from pattern
+            beamwidth_vertical: undefined // Could calculate from pattern
+        };
+    }
+    /**
+     * Ensure pattern has exactly 360 values
+     *
+     * Some antenna files might have incomplete data.
+     * This function ensures we always have 360 values.
+     *
+     * @param pattern - Raw pattern data
+     * @returns Pattern with 360 values
+     */
+    ensurePattern(pattern) {
+        if (!pattern || pattern.length === 0) {
+            // Return zero attenuation pattern (omnidirectional)
+            return new Array(360).fill(0);
+        }
+        if (pattern.length === 360) {
+            return pattern;
+        }
+        if (pattern.length < 360) {
+            // Pad with last value
+            const padded = [...pattern];
+            while (padded.length < 360) {
+                padded.push(pattern[pattern.length - 1] || 0);
+            }
+            return padded;
+        }
+        // Truncate if too long
+        return pattern.slice(0, 360);
+    }
+}
+// ============================================================================
+// SINGLETON INSTANCE
+// ============================================================================
+/**
+ * Global antenna store instance
+ *
+ * Use this instead of creating new instances.
+ * Ensures cache is shared across the application.
+ *
+ * @example
+ * import { antennaStore } from './AntennaStore';
+ *
+ * await antennaStore.initialize();
+ * const antenna = await antennaStore.getAntenna("ADU4515R17v06", "3");
+ */
+export const antennaStore = new AntennaStore();
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+/**
+ * Load antenna for a sector configuration
+ *
+ * Convenience function that loads the correct antenna
+ * based on sector configuration.
+ *
+ * @param sectorConfig - Sector configuration (must include antenna name and tilt)
+ * @returns AntennaPattern or null
+ */
+export async function loadAntennaForSector(sectorConfig) {
+    const antennaName = sectorConfig.antenna || sectorConfig.antennaModel;
+    if (!antennaName) {
+        console.error('No antenna specified in sector configuration');
+        return null;
+    }
+    const tilt = String(sectorConfig.electricalTilt);
+    return antennaStore.getAntenna(antennaName, tilt);
+}

package/dist/core/CoverageMap/data/SiteStore.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Site Store
+ *
+ * This module manages site and cell/sector data for the coverage calculator.
+ * It provides integration with existing map cell data and converts it
+ * to the format needed for coverage calculations.
+ *
+ * Integration points:
+ * - map-v2 and map-v3 cell data
+ * - Antenna store (for loading antenna patterns)
+ * - Coverage calculator (for creating configurations)
+ */
+import type { SiteConfiguration } from '../types';
+import type { Cell } from '../../../map-v3/features/cells/types';
+/**
+ * Site Store - Manages site and sector data
+ *
+ * Converts cell data from map components into site configurations
+ * suitable for coverage calculations.
+ */
+export declare class SiteStore {
+    /**
+     * Create site configuration from cell data
+     *
+     * Takes an array of cells (sectors) that belong to the same site
+     * and creates a complete site configuration for coverage calculation.
+     *
+     * Process:
+     * 1. Group cells by site (use siteName or siteId)
+     * 2. For each cell, create sector configuration
+     * 3. Load antenna patterns
+     * 4. Set RF parameters (power, frequency, tilts)
+     * 5. Assign colors for visualization
+     *
+     * @param cells - Array of cells from map component
+     * @param siteId - Optional site ID to filter (if cells from multiple sites)
+     * @returns Site configuration ready for coverage calculation
+     *
+     * @example
+     * const cells = getCellsForSite("SITE_001");
+     * const siteConfig = await siteStore.createSiteConfiguration(cells);
+     *
+     * // Use for coverage calculation
+     * const calculator = new CoverageCalculator();
+     * const result = await calculator.calculate({ site: siteConfig, ... });
+     */
+    createSiteConfiguration(cells: Cell[], siteId?: string): Promise<SiteConfiguration | null>;
+    /**
+     * Create sector configuration from a single cell
+     *
+     * @param cell - Cell data from map
+     * @param index - Sector index (for color assignment)
+     * @returns Sector configuration
+     */
+    private createSectorConfig; /**
+         * Group cells by site
+         *
+         * Takes an array of cells and groups them by site for batch processing.
+         *
+         * @param cells - Array of all cells
+         * @returns Map of siteId → cells
+         */
+    groupCellsBySite(cells: Cell[]): Map<string, Cell[]>;
+    /**
+     * Create site configurations for multiple sites
+     *
+     * @param cells - Array of all cells
+     * @returns Array of site configurations
+     */
+    createMultipleSiteConfigurations(cells: Cell[]): Promise<SiteConfiguration[]>;
+    /**
+     * Parse frequency from band string
+     *
+     * Examples:
+     *   "700" → 700 MHz
+     *   "1800" → 1800 MHz
+     *   "L700" → 700 MHz
+     *   "B3" → 1800 MHz (LTE Band 3)
+     *
+     * @param band - Band identifier
+     * @returns Frequency in MHz
+     */
+    private parseFrequency;
+    /**
+     * Convert LTE band number to center frequency
+     *
+     * @param bandNumber - LTE band number
+     * @returns Center frequency in MHz
+     */
+    private bandNumberToFrequency;
+    /**
+     * Parse mechanical tilt value
+     *
+     * Handles various formats:
+     *   - Number: 3 → 3
+     *   - String: "3" → 3
+     *   - String with units: "3°" → 3
+     *
+     * @param tilt - Tilt value (various formats)
+     * @returns Tilt as number
+     */
+    private parseTilt;
+    /**
+     * Get color for sector visualization
+     *
+     * Standard sector colors (3-sector site):
+     *   - Sector 0 (Alpha): Blue
+     *   - Sector 1 (Beta): Green
+     *   - Sector 2 (Gamma): Red
+     *
+     * @param index - Sector index
+     * @returns Hex color
+     */
+    private getSectorColor;
+    /**
+     * Extract sector name from cell name
+     *
+     * Examples:
+     *   "SITE001_Alpha" → "Alpha"
+     *   "SITE001_A" → "A"
+     *   "SITE001_1" → "Sector 1"
+     *
+     * @param cellName - Full cell name
+     * @param index - Fallback index
+     * @returns Sector name
+     */
+    private extractSectorName;
+}
+/**
+ * Global site store instance
+ *
+ * @example
+ * import { siteStore } from './SiteStore';
+ *
+ * const siteConfig = await siteStore.createSiteConfiguration(cells);
+ */
+export declare const siteStore: SiteStore;
+/**
+ * Quick site configuration creation
+ *
+ * Convenience function for creating a single site configuration.
+ *
+ * @param cells - Cells for the site
+ * @returns Site configuration or null
+ */
+export declare function createQuickSiteConfig(cells: Cell[]): Promise<SiteConfiguration | null>;
+/**
+ * Get sites from cell array
+ *
+ * Returns unique site identifiers from an array of cells.
+ *
+ * @param cells - Array of cells
+ * @returns Array of site IDs
+ */
+export declare function getSiteIds(cells: Cell[]): string[];