@smartnet360/svelte-components 0.0.10 → 0.0.12

package/dist/apps/antenna-pattern/index.d.ts

@@ -0,0 +1,15 @@
+export { default as PlotlyRadarChart } from './components/PlotlyRadarChart.svelte';
+export { default as AntennaControls } from './components/AntennaControls.svelte';
+export { default as AntennaDiagrams } from './components/AntennaDiagrams.svelte';
+export { default as AntennaSettingsModal } from './components/AntennaSettingsModal.svelte';
+export { default as JsonImporter } from './components/JsonImporter.svelte';
+export { default as MSIConverter } from './components/MSIConverter.svelte';
+export { default as DbNotification } from './components/DbNotification.svelte';
+export { default as AntennaDataDropdown } from './components/AntennaDataDropdown.svelte';
+export { antennas, selectedAntenna, searchQuery, filteredAntennas } from './stores/antennas';
+export { dbStatus, dataOperationStatus, updateDbStatus, trackDataOperation } from './stores/db-status';
+export { db, type Antenna } from './db';
+export * from './utils/db-utils';
+export * from './utils/init-db';
+export * from './utils/msi-parser';
+export * from './utils/plotly-chart-utils';

package/dist/apps/antenna-pattern/index.js

@@ -0,0 +1,19 @@
+// Individual components
+export { default as PlotlyRadarChart } from './components/PlotlyRadarChart.svelte';
+export { default as AntennaControls } from './components/AntennaControls.svelte';
+export { default as AntennaDiagrams } from './components/AntennaDiagrams.svelte';
+export { default as AntennaSettingsModal } from './components/AntennaSettingsModal.svelte';
+export { default as JsonImporter } from './components/JsonImporter.svelte';
+export { default as MSIConverter } from './components/MSIConverter.svelte';
+export { default as DbNotification } from './components/DbNotification.svelte';
+export { default as AntennaDataDropdown } from './components/AntennaDataDropdown.svelte';
+// Stores
+export { antennas, selectedAntenna, searchQuery, filteredAntennas } from './stores/antennas';
+export { dbStatus, dataOperationStatus, updateDbStatus, trackDataOperation } from './stores/db-status';
+// Database and types
+export { db } from './db';
+// Utilities
+export * from './utils/db-utils';
+export * from './utils/init-db';
+export * from './utils/msi-parser';
+export * from './utils/plotly-chart-utils';

package/dist/apps/antenna-pattern/stores/antennas.d.ts

@@ -0,0 +1,5 @@
+import type { Antenna } from '../db';
+export declare const antennas: import("svelte/store").Writable<Antenna[]>;
+export declare const selectedAntenna: import("svelte/store").Writable<Antenna | null>;
+export declare const searchQuery: import("svelte/store").Writable<string>;
+export declare const filteredAntennas: import("svelte/store").Readable<Antenna[]>;

package/dist/apps/antenna-pattern/stores/antennas.js

@@ -0,0 +1,14 @@
+import { writable, derived } from 'svelte/store';
+export const antennas = writable([]);
+export const selectedAntenna = writable(null);
+export const searchQuery = writable('');
+export const filteredAntennas = derived([antennas, searchQuery], ([$antennas, $searchQuery]) => {
+    if (!$searchQuery)
+        return $antennas;
+    const query = $searchQuery.toLowerCase();
+    return $antennas.filter(antenna => antenna.name?.toLowerCase().includes(query) ||
+        antenna.frequency?.toString().includes(query) ||
+        antenna.tilt?.toString().includes(query) ||
+        antenna.comment?.toLowerCase().includes(query) ||
+        antenna.polarization?.toLowerCase().includes(query));
+});

package/dist/apps/antenna-pattern/stores/db-status.d.ts

@@ -0,0 +1,28 @@
+export declare const dbStatus: import("svelte/store").Writable<{
+    initialized: boolean;
+    antennaCount: number;
+    lastUpdated: Date | null;
+    loading: boolean;
+    error: string | null;
+}>;
+export declare const dataOperationStatus: import("svelte/store").Writable<{
+    operation: "import" | "export" | "clear" | null;
+    inProgress: boolean;
+    success: boolean;
+    error: string | null;
+    message: string;
+    timestamp: Date | null;
+}>;
+export declare function updateDbStatus(status: Partial<{
+    initialized: boolean;
+    antennaCount: number;
+    lastUpdated: Date | null;
+    loading: boolean;
+    error: string | null;
+}>): void;
+export declare function trackDataOperation(operation: 'import' | 'export' | 'clear', status: {
+    inProgress: boolean;
+    success?: boolean;
+    error?: string | null;
+    message?: string;
+}): void;

package/dist/apps/antenna-pattern/stores/db-status.js

@@ -0,0 +1,34 @@
+import { writable } from 'svelte/store';
+// Store to track database status
+export const dbStatus = writable({
+    initialized: false,
+    antennaCount: 0,
+    lastUpdated: null,
+    loading: false,
+    error: null
+});
+// Store to track import/export operations
+export const dataOperationStatus = writable({
+    operation: null,
+    inProgress: false,
+    success: false,
+    error: null,
+    message: '',
+    timestamp: null
+});
+// Helper function to update database status
+export function updateDbStatus(status) {
+    dbStatus.update(current => ({ ...current, ...status }));
+}
+// Helper function to track data operations
+export function trackDataOperation(operation, status) {
+    dataOperationStatus.update(current => ({
+        ...current,
+        operation,
+        inProgress: status.inProgress,
+        success: status.success !== undefined ? status.success : current.success,
+        error: status.error !== undefined ? status.error : current.error,
+        message: status.message || current.message,
+        timestamp: new Date()
+    }));
+}

package/dist/apps/antenna-pattern/utils/db-utils.d.ts

@@ -0,0 +1,9 @@
+import type { Antenna } from '../db';
+export declare function loadAntennas(): Promise<Antenna[]>;
+export declare function saveAntennas(antennaData: Antenna[]): Promise<void>;
+export declare function importFromJson(jsonFile: File): Promise<Antenna[]>;
+export declare function hasImportedData(): boolean;
+export declare function exportToJson(data: Antenna[]): void;
+export declare function exportAntennas(): Promise<void>;
+export declare function clearAllAntennas(): Promise<void>;
+export declare function clearDatabase(): Promise<void>;

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

@@ -0,0 +1,180 @@
+import { db } from '../db';
+import { antennas } from '../stores/antennas';
+import { updateDbStatus, trackDataOperation } from '../stores/db-status';
+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 [];
+    }
+}
+export async function saveAntennas(antennaData) {
+    try {
+        trackDataOperation('import', { inProgress: true, message: 'Saving antenna data...' });
+        // Clear existing data 
+        await db.antennas.clear();
+        // Bulk add the new antennas
+        await db.antennas.bulkAdd(antennaData);
+        // Update the store
+        antennas.set(antennaData);
+        // Remember that we've imported data
+        localStorage.setItem('antenna-data-imported', 'true');
+        // Update database status
+        updateDbStatus({
+            initialized: true,
+            antennaCount: antennaData.length,
+            lastUpdated: new Date()
+        });
+        trackDataOperation('import', {
+            inProgress: false,
+            success: true,
+            message: `Successfully imported ${antennaData.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;
+    }
+}
+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 function hasImportedData() {
+    return localStorage.getItem('antenna-data-imported') === 'true';
+}
+export function exportToJson(data) {
+    try {
+        trackDataOperation('export', { inProgress: true, message: 'Preparing data export...' });
+        const json = JSON.stringify(data, null, 2);
+        const blob = new Blob([json], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = 'antennas.json';
+        document.body.appendChild(a);
+        a.click();
+        // Cleanup
+        setTimeout(() => {
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+            trackDataOperation('export', {
+                inProgress: false,
+                success: true,
+                message: `Successfully exported ${data.length} antennas`
+            });
+        }, 100);
+    }
+    catch (error) {
+        console.error('Error exporting antennas to JSON:', error);
+        trackDataOperation('export', {
+            inProgress: false,
+            success: false,
+            error: error instanceof Error ? error.message : 'Error exporting data',
+            message: 'Export failed'
+        });
+    }
+}
+export async function exportAntennas() {
+    try {
+        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-patterns-${new Date().toISOString().split('T')[0]}.json`;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(url);
+    }
+    catch (error) {
+        console.error('Error exporting antennas:', error);
+        throw error;
+    }
+}
+export async function clearAllAntennas() {
+    return clearDatabase();
+}
+export async function clearDatabase() {
+    try {
+        trackDataOperation('clear', { inProgress: true, message: 'Clearing database...' });
+        await db.antennas.clear();
+        antennas.set([]);
+        localStorage.removeItem('antenna-data-imported');
+        updateDbStatus({
+            antennaCount: 0,
+            lastUpdated: new Date()
+        });
+        trackDataOperation('clear', {
+            inProgress: false,
+            success: true,
+            message: 'Database cleared successfully'
+        });
+        return Promise.resolve();
+    }
+    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'
+        });
+        return Promise.reject(error);
+    }
+}

package/dist/apps/antenna-pattern/utils/init-db.d.ts

@@ -0,0 +1,2 @@
+export declare function checkAndInitDatabase(): Promise<boolean>;
+export declare function loadSampleData(): Promise<boolean>;

package/dist/apps/antenna-pattern/utils/init-db.js

@@ -0,0 +1,95 @@
+import { db } from '../db';
+import { antennas } from '../stores/antennas';
+import { updateDbStatus, trackDataOperation } from '../stores/db-status';
+// Initial data loading and checking
+export async function checkAndInitDatabase() {
+    try {
+        updateDbStatus({ loading: true, error: null });
+        // Check if database is available (not in SSR)
+        if (!db) {
+            updateDbStatus({
+                initialized: false,
+                loading: false,
+                error: 'Database not available in this environment'
+            });
+            return false;
+        }
+        // Check if we already have data
+        const count = await db.antennas.count();
+        if (count === 0) {
+            // If we don't have data, check localStorage to see if we should prompt
+            const hasPromptedImport = localStorage.getItem('antenna-import-prompted');
+            updateDbStatus({
+                initialized: true,
+                antennaCount: 0,
+                loading: false,
+                lastUpdated: null
+            });
+            if (!hasPromptedImport) {
+                // Remember that we've prompted the user
+                localStorage.setItem('antenna-import-prompted', 'true');
+                // We'll return false to indicate the app should prompt for import
+                return false;
+            }
+        }
+        else {
+            // If we have data, load it into the store
+            const data = await db.antennas.toArray();
+            antennas.set(data);
+            updateDbStatus({
+                initialized: true,
+                antennaCount: count,
+                loading: false,
+                lastUpdated: new Date()
+            });
+        }
+        return count > 0;
+    }
+    catch (error) {
+        console.error('Error checking database:', error);
+        updateDbStatus({
+            loading: false,
+            error: error instanceof Error ? error.message : 'Unknown error checking database'
+        });
+        return false;
+    }
+}
+// Helper for setting up sample data for testing
+export async function loadSampleData() {
+    try {
+        trackDataOperation('import', { inProgress: true, message: 'Loading sample data...' });
+        // Clear existing data
+        await db.antennas.clear();
+        // Fetch sample data from one of our JSON files
+        const response = await fetch('/sample-data/antennas.json');
+        const data = await response.json();
+        // Add to database
+        await db.antennas.bulkAdd(data);
+        // Update store
+        antennas.set(data);
+        // Remember that we've imported data
+        localStorage.setItem('antenna-data-imported', 'true');
+        // Update database status
+        updateDbStatus({
+            initialized: true,
+            antennaCount: data.length,
+            lastUpdated: new Date()
+        });
+        trackDataOperation('import', {
+            inProgress: false,
+            success: true,
+            message: `Successfully loaded ${data.length} sample antennas`
+        });
+        return true;
+    }
+    catch (error) {
+        console.error('Error loading sample data:', error);
+        trackDataOperation('import', {
+            inProgress: false,
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error loading sample data',
+            message: 'Failed to load sample data'
+        });
+        throw error; // Re-throw to allow caller to handle
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { Antenna } from '../db';
+export declare function parseMSIFile(file: File): Promise<Antenna>;
+export declare function parseFolder(directoryHandle: FileSystemDirectoryHandle, recursive?: boolean): Promise<Antenna[]>;

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

@@ -0,0 +1,197 @@
+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;
+    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
+        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
+        if (filenameParts.length > 4 && filenameParts[4].startsWith('M')) {
+            filenameMetadata.polarization = filenameParts[4].replace('M', '-');
+        }
+        // Extract tilt
+        if (filenameParts.length > 5 && filenameParts[5].endsWith('T')) {
+            filenameMetadata.tilt_from_filename = filenameParts[5].replace('T', '');
+        }
+    }
+    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;
+}
+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;
+}