@smartnet360/svelte-components 0.0.118 → 0.0.120

package/dist/apps/antenna-pattern/utils/antenna-helpers.js

@@ -0,0 +1,140 @@
+/**
+ * Antenna Data Utilities
+ * Helper functions for working with antenna data, tilts, and searches
+ */
+/**
+ * Find an antenna by name with fallback matching strategies
+ * @param antennas - Array of all antennas
+ * @param name - Name pattern to search for
+ * @returns Search result with antenna and match type
+ */
+export function findAntennaByName(antennas, name) {
+    if (!name || antennas.length === 0) {
+        return { antenna: null, matchType: 'not-found' };
+    }
+    // Strategy 1: Exact match
+    let found = antennas.find(a => a.name === name);
+    if (found) {
+        return { antenna: found, matchType: 'exact' };
+    }
+    // Strategy 2: Case-insensitive match
+    const lowerName = name.toLowerCase();
+    found = antennas.find(a => a.name.toLowerCase() === lowerName);
+    if (found) {
+        return { antenna: found, matchType: 'case-insensitive' };
+    }
+    // Strategy 3: Partial match (name contains search term)
+    found = antennas.find(a => a.name.toLowerCase().includes(lowerName));
+    if (found) {
+        return { antenna: found, matchType: 'partial' };
+    }
+    return { antenna: null, matchType: 'not-found' };
+}
+/**
+ * Collect all available electrical tilts for an antenna model
+ * Searches all antennas with the same name and extracts unique tilt values
+ * @param antennas - Array of all antennas
+ * @param antennaName - The antenna model name
+ * @param frequency - Optional frequency to filter by
+ * @returns Sorted array of tilt values as strings
+ */
+export function collectAvailableTilts(antennas, antennaName, frequency) {
+    if (!antennaName)
+        return ['0'];
+    // Find all antennas with the same name
+    let sameModel = antennas.filter(a => a.name === antennaName);
+    // Optionally filter by frequency
+    if (frequency) {
+        sameModel = sameModel.filter(a => a.frequency === frequency);
+    }
+    // Collect all unique tilts
+    const allTilts = new Set();
+    for (const antenna of sameModel) {
+        if (antenna.tilt) {
+            const tiltStr = antenna.tilt.toString();
+            if (tiltStr.includes(',')) {
+                tiltStr.split(',').forEach(t => allTilts.add(t.trim()));
+            }
+            else {
+                allTilts.add(tiltStr.trim());
+            }
+        }
+    }
+    // Return sorted array (numerically)
+    const sorted = Array.from(allTilts).sort((a, b) => parseFloat(a) - parseFloat(b));
+    return sorted.length > 0 ? sorted : ['0'];
+}
+/**
+ * Collect all available frequencies for an antenna model
+ * @param antennas - Array of all antennas
+ * @param antennaName - The antenna model name
+ * @returns Sorted array of unique frequencies
+ */
+export function collectAvailableFrequencies(antennas, antennaName) {
+    if (!antennaName)
+        return [];
+    const sameModel = antennas.filter(a => a.name === antennaName);
+    const frequencies = new Set();
+    for (const antenna of sameModel) {
+        if (antenna.frequency) {
+            frequencies.add(antenna.frequency);
+        }
+    }
+    return Array.from(frequencies).sort((a, b) => a - b);
+}
+/**
+ * Find the index of a tilt value in the available tilts array
+ * @param availableTilts - Array of available tilt values
+ * @param tiltValue - The tilt value to find (as number)
+ * @returns Index in the array, or 0 if not found
+ */
+export function findTiltIndex(availableTilts, tiltValue) {
+    const index = availableTilts.findIndex(t => parseInt(t, 10) === tiltValue);
+    return index >= 0 ? index : 0;
+}
+/**
+ * Get the tilt value at a given index
+ * @param availableTilts - Array of available tilt values
+ * @param index - Index to retrieve
+ * @returns Tilt value as number
+ */
+export function getTiltValue(availableTilts, index) {
+    const tilt = availableTilts[index];
+    return tilt ? parseInt(tilt, 10) : 0;
+}
+/**
+ * Find an antenna with specific name, frequency, and tilt
+ * @param antennas - Array of all antennas
+ * @param name - Antenna model name
+ * @param frequency - Target frequency (optional)
+ * @param tiltValue - Target tilt value
+ * @returns Matching antenna or null
+ */
+export function findAntennaWithTilt(antennas, name, frequency, tiltValue) {
+    return antennas.find(antenna => {
+        if (antenna.name !== name)
+            return false;
+        if (frequency && antenna.frequency !== frequency)
+            return false;
+        if (antenna.tilt) {
+            const tiltStr = antenna.tilt.toString();
+            const antennaTilts = tiltStr.includes(',')
+                ? tiltStr.split(',').map(t => t.trim())
+                : [tiltStr.trim()];
+            return antennaTilts.includes(tiltValue);
+        }
+        return tiltValue === '0';
+    }) || null;
+}
+/**
+ * Get unique antenna models (by name)
+ * @param antennas - Array of all antennas
+ * @returns Array of unique antenna names
+ */
+export function getUniqueAntennaModels(antennas) {
+    const names = new Set();
+    for (const antenna of antennas) {
+        names.add(antenna.name);
+    }
+    return Array.from(names).sort();
+}

package/dist/apps/antenna-tools/band-config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Antenna Tools - Band Configuration
+ * Frequency band definitions and purge utilities
+ */
+import type { BandDefinition, Antenna, RawAntenna } from './types';
+import { STANDARD_BANDS } from './types';
+export { STANDARD_BANDS };
+export type { BandDefinition };
+/**
+ * Get the center frequency of a band
+ */
+export declare function getBandCenterFrequency(band: BandDefinition): number;
+/**
+ * Find which band a frequency belongs to
+ * @returns Band definition or null if not in any standard band
+ */
+export declare function findBandForFrequency(frequencyMHz: number): BandDefinition | null;
+/**
+ * Check if a frequency is within any standard band
+ */
+export declare function isFrequencyInStandardBand(frequencyMHz: number): boolean;
+/**
+ * Purge antennas - keep only one per band (closest to center frequency)
+ *
+ * For each antenna name + tilt combination:
+ * - For each standard band, find antennas within the band's frequency range
+ * - Keep only the one closest to the center frequency
+ * - Update frequency to band name (700, 800, etc.)
+ * - Store original frequency in originalFrequency field
+ *
+ * @param rawAntennas - Antennas parsed from MSI files (with actual MHz frequencies)
+ * @returns Purged antennas with band names as frequencies
+ */
+export declare function purgeAntennas(rawAntennas: RawAntenna[]): Antenna[];
+/**
+ * Get purge statistics
+ */
+export interface PurgeStats {
+    /** Total raw antennas before purge */
+    totalBefore: number;
+    /** Total antennas after purge */
+    totalAfter: number;
+    /** Number of antennas removed */
+    removed: number;
+    /** Reduction percentage */
+    reductionPercent: number;
+    /** Antennas per band */
+    perBand: Record<string, number>;
+}
+/**
+ * Calculate purge statistics
+ */
+export declare function calculatePurgeStats(rawCount: number, purgedAntennas: Antenna[]): PurgeStats;

package/dist/apps/antenna-tools/band-config.js

@@ -0,0 +1,112 @@
+/**
+ * Antenna Tools - Band Configuration
+ * Frequency band definitions and purge utilities
+ */
+import { STANDARD_BANDS } from './types';
+// Re-export for convenience
+export { STANDARD_BANDS };
+/**
+ * Get the center frequency of a band
+ */
+export function getBandCenterFrequency(band) {
+    return (band.dlMin + band.dlMax) / 2;
+}
+/**
+ * Find which band a frequency belongs to
+ * @returns Band definition or null if not in any standard band
+ */
+export function findBandForFrequency(frequencyMHz) {
+    return STANDARD_BANDS.find(band => frequencyMHz >= band.dlMin && frequencyMHz <= band.dlMax) || null;
+}
+/**
+ * Check if a frequency is within any standard band
+ */
+export function isFrequencyInStandardBand(frequencyMHz) {
+    return findBandForFrequency(frequencyMHz) !== null;
+}
+/**
+ * Group raw antennas by name and tilt
+ */
+function groupByNameAndTilt(antennas) {
+    const groups = new Map();
+    for (const antenna of antennas) {
+        const key = `${antenna.name}__${antenna.tilt}`;
+        const group = groups.get(key) || [];
+        group.push(antenna);
+        groups.set(key, group);
+    }
+    return groups;
+}
+/**
+ * Purge antennas - keep only one per band (closest to center frequency)
+ *
+ * For each antenna name + tilt combination:
+ * - For each standard band, find antennas within the band's frequency range
+ * - Keep only the one closest to the center frequency
+ * - Update frequency to band name (700, 800, etc.)
+ * - Store original frequency in originalFrequency field
+ *
+ * @param rawAntennas - Antennas parsed from MSI files (with actual MHz frequencies)
+ * @returns Purged antennas with band names as frequencies
+ */
+export function purgeAntennas(rawAntennas) {
+    const purged = [];
+    // Group by antenna name + tilt
+    const groups = groupByNameAndTilt(rawAntennas);
+    for (const [_key, group] of groups) {
+        // For each standard band
+        for (const band of STANDARD_BANDS) {
+            // Find antennas in this band's frequency range
+            const inBand = group.filter(a => a.frequency >= band.dlMin && a.frequency <= band.dlMax);
+            if (inBand.length === 0)
+                continue;
+            // Find the one closest to center frequency
+            const centerFreq = getBandCenterFrequency(band);
+            const closest = inBand.reduce((best, current) => {
+                const bestDist = Math.abs(best.frequency - centerFreq);
+                const currDist = Math.abs(current.frequency - centerFreq);
+                return currDist < bestDist ? current : best;
+            });
+            // Create purged antenna with band name as frequency
+            // Explicitly copy only serializable properties (avoid spread which may include non-cloneable data)
+            const purgedAntenna = {
+                name: closest.name,
+                frequency: parseInt(band.name, 10), // Use band name as frequency (700, 800, etc.)
+                originalFrequency: closest.frequency, // Store original MHz
+                gain_dBd: closest.gain_dBd,
+                tilt: closest.tilt,
+                comment: closest.comment,
+                horizontal: closest.horizontal,
+                pattern: Array.isArray(closest.pattern) ? [...closest.pattern] : [],
+                vertical_pattern: Array.isArray(closest.vertical_pattern) ? [...closest.vertical_pattern] : [],
+                polarization: closest.polarization,
+                x_pol: closest.x_pol,
+                co: closest.co,
+                tilt_from_filename: closest.tilt_from_filename,
+                sourcePath: closest.sourcePath,
+            };
+            purged.push(purgedAntenna);
+        }
+    }
+    return purged;
+}
+/**
+ * Calculate purge statistics
+ */
+export function calculatePurgeStats(rawCount, purgedAntennas) {
+    const perBand = {};
+    for (const antenna of purgedAntennas) {
+        const bandName = antenna.frequency.toString();
+        perBand[bandName] = (perBand[bandName] || 0) + 1;
+    }
+    const totalAfter = purgedAntennas.length;
+    const removed = rawCount - totalAfter;
+    const reductionPercent = rawCount > 0 ? Math.round((removed / rawCount) * 100) : 0;
+    return {
+        totalBefore: rawCount,
+        totalAfter,
+        removed,
+        reductionPercent,
+        perBand
+    };
+}