@smartnet360/svelte-components 0.0.119 → 0.0.120

package/dist/apps/antenna-tools/utils/db-utils.js

@@ -0,0 +1,266 @@
+/**
+ * Antenna Tools - Database Utilities
+ * CRUD operations for antenna data with automatic purge on import
+ */
+import { db } from '../db';
+import { antennas } from '../stores/antennas';
+import { updateDbStatus, trackDataOperation } from '../stores/db-status';
+import { purgeAntennas, calculatePurgeStats } from '../band-config';
+// ─────────────────────────────────────────────────────────────────────────────
+// LOAD OPERATIONS
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Load all antennas from database
+ */
+export async function loadAntennas() {
+    try {
+        updateDbStatus({ loading: true, error: null });
+        // Return empty array if db is not available (SSR environment)
+        if (!db) {
+            updateDbStatus({
+                initialized: false,
+                loading: false,
+                error: 'Database not available in this environment'
+            });
+            return [];
+        }
+        const data = await db.antennas.toArray();
+        antennas.set(data);
+        updateDbStatus({
+            initialized: true,
+            antennaCount: data.length,
+            lastUpdated: new Date(),
+            loading: false
+        });
+        return data;
+    }
+    catch (error) {
+        console.error('Error loading antennas from IndexedDB:', error);
+        updateDbStatus({
+            loading: false,
+            error: error instanceof Error ? error.message : 'Unknown database error'
+        });
+        return [];
+    }
+}
+/**
+ * Save raw antennas to database with automatic purge
+ *
+ * This is the main import function:
+ * 1. Takes raw antennas (with actual MHz frequencies)
+ * 2. Purges to keep only one per band (closest to center)
+ * 3. Saves purged antennas to database
+ *
+ * @param rawAntennas - Antennas parsed from MSI files
+ * @returns Import result with purge statistics
+ */
+export async function saveAntennasWithPurge(rawAntennas) {
+    try {
+        trackDataOperation('import', { inProgress: true, message: 'Purging frequencies...' });
+        // Step 1: Purge - keep only one antenna per band
+        const purgedAntennas = purgeAntennas(rawAntennas);
+        const purgeStats = calculatePurgeStats(rawAntennas.length, purgedAntennas);
+        console.log(`[saveAntennasWithPurge] Purge complete: ${purgeStats.totalBefore} → ${purgeStats.totalAfter} antennas (${purgeStats.reductionPercent}% reduction)`);
+        trackDataOperation('import', { inProgress: true, message: `Saving ${purgedAntennas.length} antennas...` });
+        // Step 2: Clear existing data 
+        await db.antennas.clear();
+        // Step 3: Bulk add the purged antennas
+        await db.antennas.bulkAdd(purgedAntennas);
+        // Update the store
+        antennas.set(purgedAntennas);
+        // Remember that we've imported data
+        localStorage.setItem('antenna-tools-data-imported', 'true');
+        // Update database status
+        updateDbStatus({
+            initialized: true,
+            antennaCount: purgedAntennas.length,
+            lastUpdated: new Date()
+        });
+        trackDataOperation('import', {
+            inProgress: false,
+            success: true,
+            message: `Imported ${purgedAntennas.length} antennas (${purgeStats.reductionPercent}% reduction)`
+        });
+        return { success: true, purgeStats };
+    }
+    catch (error) {
+        console.error('Error saving antennas to IndexedDB:', error);
+        trackDataOperation('import', {
+            inProgress: false,
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error during import',
+            message: 'Import failed'
+        });
+        return {
+            success: false,
+            purgeStats: { totalBefore: rawAntennas.length, totalAfter: 0, removed: rawAntennas.length, reductionPercent: 100, perBand: {} },
+            error: error instanceof Error ? error.message : 'Unknown error'
+        };
+    }
+}
+/**
+ * Save antennas directly (without purge) - for pre-purged data
+ */
+export async function saveAntennas(antennaData) {
+    try {
+        trackDataOperation('import', { inProgress: true, message: 'Saving antenna data...' });
+        // Clear existing data 
+        await db.antennas.clear();
+        // Sanitize data to ensure it's cloneable for IndexedDB
+        const sanitizedData = antennaData.map(a => ({
+            name: a.name,
+            frequency: a.frequency,
+            originalFrequency: a.originalFrequency,
+            gain_dBd: a.gain_dBd,
+            tilt: a.tilt,
+            comment: a.comment,
+            horizontal: a.horizontal,
+            pattern: Array.isArray(a.pattern) ? [...a.pattern] : [],
+            vertical_pattern: Array.isArray(a.vertical_pattern) ? [...a.vertical_pattern] : [],
+            polarization: a.polarization,
+            x_pol: a.x_pol,
+            co: a.co,
+            tilt_from_filename: a.tilt_from_filename,
+            sourcePath: a.sourcePath,
+        }));
+        // Bulk add the new antennas
+        await db.antennas.bulkAdd(sanitizedData);
+        // Update the store
+        antennas.set(sanitizedData);
+        // Remember that we've imported data
+        localStorage.setItem('antenna-tools-data-imported', 'true');
+        // Update database status
+        updateDbStatus({
+            initialized: true,
+            antennaCount: sanitizedData.length,
+            lastUpdated: new Date()
+        });
+        trackDataOperation('import', {
+            inProgress: false,
+            success: true,
+            message: `Successfully imported ${sanitizedData.length} antennas`
+        });
+    }
+    catch (error) {
+        console.error('Error saving antennas to IndexedDB:', error);
+        trackDataOperation('import', {
+            inProgress: false,
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error during import',
+            message: 'Import failed'
+        });
+        throw error;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// IMPORT FROM FILES
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Import from JSON file (expects pre-purged data)
+ */
+export async function importFromJson(jsonFile) {
+    try {
+        trackDataOperation('import', {
+            inProgress: true,
+            message: `Reading file: ${jsonFile.name}...`
+        });
+        const text = await jsonFile.text();
+        const data = JSON.parse(text);
+        trackDataOperation('import', {
+            inProgress: true,
+            message: `Importing ${data.length} antennas...`
+        });
+        await saveAntennas(data);
+        return data;
+    }
+    catch (error) {
+        console.error('Error importing antennas from JSON:', error);
+        trackDataOperation('import', {
+            inProgress: false,
+            success: false,
+            error: error instanceof Error ? error.message : 'Invalid JSON file or format',
+            message: 'Import failed'
+        });
+        throw error;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// EXPORT OPERATIONS
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Export all antennas to JSON file download
+ */
+export async function exportAntennas() {
+    try {
+        trackDataOperation('export', { inProgress: true, message: 'Preparing data export...' });
+        const data = await db.antennas.toArray();
+        const jsonData = JSON.stringify(data, null, 2);
+        // Create and download file
+        const blob = new Blob([jsonData], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = `antenna-tools-${new Date().toISOString().split('T')[0]}.json`;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(url);
+        trackDataOperation('export', {
+            inProgress: false,
+            success: true,
+            message: `Successfully exported ${data.length} antennas`
+        });
+    }
+    catch (error) {
+        console.error('Error exporting antennas:', error);
+        trackDataOperation('export', {
+            inProgress: false,
+            success: false,
+            error: error instanceof Error ? error.message : 'Error exporting data',
+            message: 'Export failed'
+        });
+        throw error;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// CLEAR OPERATIONS
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Clear all antenna data from database
+ */
+export async function clearAllAntennas() {
+    try {
+        trackDataOperation('clear', { inProgress: true, message: 'Clearing database...' });
+        await db.antennas.clear();
+        antennas.set([]);
+        localStorage.removeItem('antenna-tools-data-imported');
+        updateDbStatus({
+            antennaCount: 0,
+            lastUpdated: new Date()
+        });
+        trackDataOperation('clear', {
+            inProgress: false,
+            success: true,
+            message: 'Database cleared successfully'
+        });
+    }
+    catch (error) {
+        console.error('Error clearing database:', error);
+        trackDataOperation('clear', {
+            inProgress: false,
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error clearing database',
+            message: 'Failed to clear database'
+        });
+        throw error;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// UTILITY FUNCTIONS
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Check if data has been imported before
+ */
+export function hasImportedData() {
+    return localStorage.getItem('antenna-tools-data-imported') === 'true';
+}

package/dist/apps/antenna-tools/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Antenna Tools - Utils Index
+ */
+export * from './msi-parser';
+export * from './db-utils';
+export * from './antenna-helpers';
+export * from './recent-antennas';

package/dist/apps/antenna-tools/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * Antenna Tools - Utils Index
+ */
+export * from './msi-parser';
+export * from './db-utils';
+export * from './antenna-helpers';
+export * from './recent-antennas';

package/dist/apps/antenna-tools/utils/msi-parser.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Antenna Tools - MSI Parser
+ * Parses MSI antenna pattern files
+ *
+ * This is adapted from antenna-pattern/utils/msi-parser.ts
+ * Kept the same parsing logic as requested
+ */
+import type { RawAntenna } from '../types';
+/**
+ * Parse a single MSI file and return raw antenna data
+ * @param file - MSI or PNT file
+ * @returns Parsed antenna with actual MHz frequency
+ */
+export declare function parseMSIFile(file: File): Promise<RawAntenna>;
+/**
+ * Parse a folder of MSI files recursively
+ * @param directoryHandle - File system directory handle
+ * @param recursive - Whether to process subdirectories
+ * @returns Array of parsed antennas
+ */
+export declare function parseFolder(directoryHandle: FileSystemDirectoryHandle, recursive?: boolean): Promise<RawAntenna[]>;

package/dist/apps/antenna-tools/utils/msi-parser.js

@@ -0,0 +1,215 @@
+/**
+ * Antenna Tools - MSI Parser
+ * Parses MSI antenna pattern files
+ *
+ * This is adapted from antenna-pattern/utils/msi-parser.ts
+ * Kept the same parsing logic as requested
+ */
+/**
+ * Parse a single MSI file and return raw antenna data
+ * @param file - MSI or PNT file
+ * @returns Parsed antenna with actual MHz frequency
+ */
+export async function parseMSIFile(file) {
+    const text = await file.text();
+    const lines = text.split('\n');
+    // Initialize the result object with default values
+    const result = {
+        name: '',
+        frequency: 0,
+        gain_dBd: 0.0,
+        tilt: 'NO',
+        horizontal: 360,
+        pattern: Array(360).fill(0),
+        vertical_pattern: Array(360).fill(0)
+    };
+    // Parse filename for metadata
+    const filename = file.name.replace(/\.(msi|pnt)$/i, '');
+    const filenameParts = filename.split('_');
+    // Initialize filename metadata
+    const filenameMetadata = {
+        name_from_filename: '',
+        frequency_from_filename: 0,
+        x_pol: '',
+        co: '',
+        polarization: '',
+        tilt_from_filename: ''
+    };
+    if (filenameParts.length >= 5) {
+        filenameMetadata.name_from_filename = filenameParts[0];
+        // Extract frequency from filename (e.g., "0699" -> 699)
+        if (filenameParts.length > 1 && !isNaN(parseInt(filenameParts[1]))) {
+            filenameMetadata.frequency_from_filename = parseInt(filenameParts[1]);
+        }
+        // Extract X polarization
+        if (filenameParts.length > 2) {
+            filenameMetadata.x_pol = filenameParts[2];
+        }
+        // Extract CO
+        if (filenameParts.length > 3) {
+            filenameMetadata.co = filenameParts[3];
+        }
+        // Extract polarization (e.g., "M45" -> "-45")
+        if (filenameParts.length > 4 && filenameParts[4].startsWith('M')) {
+            filenameMetadata.polarization = filenameParts[4].replace('M', '-');
+        }
+        // Extract tilt (e.g., "03T" -> "03")
+        if (filenameParts.length > 5 && (filenameParts[5].endsWith('T') || filenameParts[5].endsWith('t'))) {
+            filenameMetadata.tilt_from_filename = filenameParts[5].replace(/[Tt]$/, '');
+        }
+    }
+    let currentSection = null;
+    // Process each line
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // Skip empty lines
+        if (!trimmedLine)
+            continue;
+        // Check for metadata lines
+        if (trimmedLine.startsWith('NAME ')) {
+            if (!filenameMetadata.name_from_filename) {
+                result.name = trimmedLine.substring(5).trim();
+            }
+            else {
+                result.name = filenameMetadata.name_from_filename;
+            }
+        }
+        else if (trimmedLine.startsWith('FREQUENCY ')) {
+            if (!filenameMetadata.frequency_from_filename) {
+                const freqText = trimmedLine.substring(10).trim();
+                const freqParts = freqText.split(' ');
+                if (freqParts.length > 0) {
+                    try {
+                        result.frequency = parseInt(freqParts[0]);
+                    }
+                    catch (error) {
+                        result.frequency = 0;
+                    }
+                }
+            }
+            else {
+                result.frequency = filenameMetadata.frequency_from_filename;
+            }
+        }
+        else if (trimmedLine.startsWith('GAIN ')) {
+            const gainParts = trimmedLine.substring(5).trim().split(' ');
+            result.gain_dBd = parseFloat(gainParts[0]);
+        }
+        else if (trimmedLine.startsWith('TILT ')) {
+            if (!filenameMetadata.tilt_from_filename) {
+                result.tilt = trimmedLine.substring(5).trim();
+            }
+            else {
+                result.tilt = filenameMetadata.tilt_from_filename;
+            }
+        }
+        else if (trimmedLine.startsWith('COMMENT ')) {
+            result.comment = trimmedLine.substring(8).trim();
+        }
+        else if (trimmedLine.startsWith('HORIZONTAL ')) {
+            currentSection = 'horizontal';
+            result.horizontal = parseInt(trimmedLine.substring(11).trim());
+        }
+        else if (trimmedLine.startsWith('VERTICAL ')) {
+            currentSection = 'vertical';
+        }
+        // Parse pattern data lines (pattern values represent attenuation where 0 is max signal)
+        else if (currentSection === 'horizontal' && trimmedLine.includes(' ')) {
+            try {
+                const parts = trimmedLine.split(' ').filter(part => part.trim() !== '');
+                if (parts.length >= 2) {
+                    const angleStr = parts[0];
+                    const attenuationStr = parts[1];
+                    const angle = parseInt(angleStr);
+                    const attenuation = parseFloat(attenuationStr);
+                    // Ensure the angle is within bounds
+                    if (angle >= 0 && angle < 360) {
+                        // Store as attenuation values (0 = max signal, higher values = more attenuation)
+                        result.pattern[angle] = attenuation;
+                    }
+                }
+            }
+            catch (error) {
+                // Skip lines that can't be parsed
+            }
+        }
+        else if (currentSection === 'vertical' && trimmedLine.includes(' ')) {
+            try {
+                const parts = trimmedLine.split(' ').filter(part => part.trim() !== '');
+                if (parts.length >= 2) {
+                    const angleStr = parts[0];
+                    const attenuationStr = parts[1];
+                    const angle = parseInt(angleStr);
+                    const attenuation = parseFloat(attenuationStr);
+                    // Ensure the angle is within bounds
+                    if (angle >= 0 && angle < 360) {
+                        // Store as attenuation values (0 = max signal, higher values = more attenuation)
+                        result.vertical_pattern[angle] = attenuation;
+                    }
+                }
+            }
+            catch (error) {
+                // Skip lines that can't be parsed
+            }
+        }
+    }
+    // Ensure filename metadata is included in the final result
+    if (!result.name && filenameMetadata.name_from_filename) {
+        result.name = filenameMetadata.name_from_filename;
+    }
+    if (!result.frequency && filenameMetadata.frequency_from_filename) {
+        result.frequency = filenameMetadata.frequency_from_filename;
+    }
+    if (!result.tilt && filenameMetadata.tilt_from_filename) {
+        result.tilt = filenameMetadata.tilt_from_filename;
+    }
+    // Always include these fields from the filename
+    result.x_pol = filenameMetadata.x_pol;
+    result.co = filenameMetadata.co;
+    result.polarization = filenameMetadata.polarization;
+    return result;
+}
+/**
+ * Parse a folder of MSI files recursively
+ * @param directoryHandle - File system directory handle
+ * @param recursive - Whether to process subdirectories
+ * @returns Array of parsed antennas
+ */
+export async function parseFolder(directoryHandle, recursive = true) {
+    const antennas = [];
+    // Process directory recursively
+    async function processDirectory(dirHandle, path = '') {
+        const iterator = dirHandle.values();
+        for await (const entry of iterator) {
+            if (entry.kind === 'file') {
+                try {
+                    // Type assertion to access getFile method
+                    const fileHandle = entry;
+                    const file = await fileHandle.getFile();
+                    const ext = file.name.split('.').pop()?.toLowerCase();
+                    if (ext === 'msi' || ext === 'pnt') {
+                        try {
+                            const antenna = await parseMSIFile(file);
+                            // Add the path info to help identify where the file was found
+                            antenna.sourcePath = path ? `${path}/${file.name}` : file.name;
+                            antennas.push(antenna);
+                        }
+                        catch (error) {
+                            console.error(`Error parsing file ${path ? `${path}/` : ''}${file.name}:`, error);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('Error accessing file:', error);
+                }
+            }
+            else if (entry.kind === 'directory' && recursive) {
+                // Process subdirectory if recursive flag is true
+                const subDirPath = path ? `${path}/${entry.name}` : entry.name;
+                await processDirectory(entry, subDirPath);
+            }
+        }
+    }
+    await processDirectory(directoryHandle);
+    return antennas;
+}

package/dist/apps/antenna-tools/utils/recent-antennas.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Antenna Tools - Recent Antennas
+ * Track recently selected antennas in localStorage
+ */
+import type { Antenna } from '../types';
+/**
+ * Get recently selected antennas from localStorage
+ */
+export declare function getRecentAntennas(): Antenna[];
+/**
+ * Add an antenna to the recent list
+ */
+export declare function addToRecentAntennas(antenna: Antenna): void;
+/**
+ * Clear recent antennas list
+ */
+export declare function clearRecentAntennas(): void;
+/**
+ * Sort antennas to show recent ones first, then alphabetical
+ */
+export declare function sortAntennasWithRecent(antennas: Antenna[]): {
+    recent: Antenna[];
+    others: Antenna[];
+};

package/dist/apps/antenna-tools/utils/recent-antennas.js

@@ -0,0 +1,64 @@
+/**
+ * Antenna Tools - Recent Antennas
+ * Track recently selected antennas in localStorage
+ */
+const RECENT_ANTENNAS_KEY = 'antenna-tools-recent';
+const MAX_RECENT_ANTENNAS = 10;
+/**
+ * Get recently selected antennas from localStorage
+ */
+export function getRecentAntennas() {
+    try {
+        const stored = localStorage.getItem(RECENT_ANTENNAS_KEY);
+        if (!stored)
+            return [];
+        const recent = JSON.parse(stored);
+        return Array.isArray(recent) ? recent : [];
+    }
+    catch (error) {
+        console.warn('Failed to load recent antennas:', error);
+        return [];
+    }
+}
+/**
+ * Add an antenna to the recent list
+ */
+export function addToRecentAntennas(antenna) {
+    try {
+        let recent = getRecentAntennas();
+        // Remove if already exists (to move to top)
+        recent = recent.filter(a => a.id !== antenna.id);
+        // Add to beginning
+        recent.unshift(antenna);
+        // Keep only the max number
+        recent = recent.slice(0, MAX_RECENT_ANTENNAS);
+        // Save to localStorage
+        localStorage.setItem(RECENT_ANTENNAS_KEY, JSON.stringify(recent));
+    }
+    catch (error) {
+        console.warn('Failed to save recent antenna:', error);
+    }
+}
+/**
+ * Clear recent antennas list
+ */
+export function clearRecentAntennas() {
+    try {
+        localStorage.removeItem(RECENT_ANTENNAS_KEY);
+    }
+    catch (error) {
+        console.warn('Failed to clear recent antennas:', error);
+    }
+}
+/**
+ * Sort antennas to show recent ones first, then alphabetical
+ */
+export function sortAntennasWithRecent(antennas) {
+    const recentAntennas = getRecentAntennas();
+    const recentIds = new Set(recentAntennas.map(a => a.id));
+    // Filter antennas that exist in current list and are recent
+    const recent = recentAntennas.filter(recentAntenna => antennas.some(antenna => antenna.id === recentAntenna.id));
+    // Get other antennas (not in recent list)
+    const others = antennas.filter(antenna => !recentIds.has(antenna.id));
+    return { recent, others };
+}

package/package.json

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