@smartnet360/svelte-components 0.0.122 → 0.0.124

package/dist/apps/antenna-tools/components/MSIConverter.svelte

@@ -1,22 +1,30 @@
 <svelte:options runes={true} />
 
 <script lang="ts">
-  import { parseFolder } from '../utils/msi-parser';
+  import { parseFolderWithErrors, type ParseProgress, type ParseError } from '../utils/msi-parser';
   import { saveAntennasWithPurge, type ImportResult } from '../utils/db-utils';
   import { STANDARD_BANDS } from '../band-config';
-  import type { RawAntenna, Antenna } from '../types';
+  import type { RawAntenna, Antenna, BandDefinition } from '../types';
   
   interface Props {
     onDataRefresh?: () => void;
+    /** Custom band definitions for purge (defaults to STANDARD_BANDS) */
+    customBands?: BandDefinition[];
   }
   
-  let { onDataRefresh }: Props = $props();
+  let { onDataRefresh, customBands }: Props = $props();
+  
+  // Use custom bands if provided, otherwise use standard bands
+  let activeBands = $derived(customBands ?? STANDARD_BANDS);
   
   let rawAntennas = $state<RawAntenna[]>([]);
   let isLoading = $state(false);
   let error = $state('');
   let message = $state('');
   let importResult = $state<ImportResult | null>(null);
+  let parseProgress = $state<ParseProgress | null>(null);
+  let parseErrors = $state<ParseError[]>([]);
+  let showErrorDetails = $state(false);
   
   let recursiveScan = $state(true);
   
@@ -32,19 +40,32 @@
       error = '';
       message = 'Selecting folder...';
       importResult = null;
+      parseProgress = null;
+      parseErrors = [];
+      showErrorDetails = false;
       
       // Ask user to select a folder
       const directoryPicker = window.showDirectoryPicker as () => Promise<FileSystemDirectoryHandle>;
       const directoryHandle = await directoryPicker();
       message = recursiveScan ? 
-        'Reading and parsing files recursively (including all subfolders)...' : 
-        'Reading and parsing files (top-level folder only)...';
+        'Scanning folders and parsing files...' : 
+        'Parsing files (top-level folder only)...';
+      
+      // Parse all MSI/PNT files in the folder, with recursive option and progress
+      const result = await parseFolderWithErrors(directoryHandle, recursiveScan, (progress) => {
+        parseProgress = progress;
+      });
       
-      // Parse all MSI/PNT files in the folder, with recursive option
-      rawAntennas = await parseFolder(directoryHandle, recursiveScan);
+      rawAntennas = result.antennas;
+      parseErrors = result.errors;
       
-      if (rawAntennas.length === 0) {
+      parseProgress = null;
+      if (rawAntennas.length === 0 && parseErrors.length === 0) {
         message = 'No MSI or PNT files found in the selected folder.';
+      } else if (rawAntennas.length === 0 && parseErrors.length > 0) {
+        message = `No files were successfully parsed. ${parseErrors.length} file(s) failed.`;
+      } else if (parseErrors.length > 0) {
+        message = `Parsed ${rawAntennas.length} antenna files${recursiveScan ? ' from all folders' : ''}. ${parseErrors.length} file(s) failed.`;
       } else {
         message = `Successfully parsed ${rawAntennas.length} antenna files${recursiveScan ? ' from all folders' : ''}.`;
       }
@@ -75,8 +96,8 @@
       isLoading = true;
       message = 'Purging frequencies and saving to database...';
       
-      // Save with automatic purge
-      importResult = await saveAntennasWithPurge(rawAntennas);
+      // Save with automatic purge (using custom bands if provided)
+      importResult = await saveAntennasWithPurge(rawAntennas, customBands);
       
       if (importResult.success) {
         const stats = importResult.purgeStats;
@@ -122,16 +143,16 @@
     <header class="d-flex flex-column flex-lg-row align-items-lg-center justify-content-between gap-3 mb-4">
       <div>
         <h1 class="h3 mb-2">Convert MSI / PNT to JSON</h1>
-        <p class="text-muted mb-0">Scan a folder of antenna definitions. Files will be purged to keep only standard bands.</p>
+        <p class="text-muted mb-0">Scan a folder of antenna definitions. Files will be purged to keep only configured bands.</p>
       </div>
       <span class="badge text-bg-success">Local processing</span>
     </header>
 
-    <!-- Standard Bands Info -->
+    <!-- Bands Info -->
     <div class="alert alert-info border-0 bg-info-subtle mb-4">
-      <strong><i class="bi bi-info-circle me-2"></i>Standard Bands:</strong>
+      <strong><i class="bi bi-info-circle me-2"></i>{customBands ? 'Custom' : 'Standard'} Bands:</strong>
       <div class="d-flex flex-wrap gap-2 mt-2">
-        {#each STANDARD_BANDS as band}
+        {#each activeBands as band}
           <span class="badge text-bg-primary">{band.name} MHz ({band.dlMin}-{band.dlMax})</span>
         {/each}
       </div>
@@ -183,13 +204,100 @@
         </div>
       {/if}
 
-      {#if message && !error}
+      <!-- Progress indicator during parsing -->
+      {#if isLoading && parseProgress}
+        <div class="card border-info">
+          <div class="card-body">
+            <div class="d-flex align-items-center gap-3 mb-3">
+              <div class="spinner-border spinner-border-sm text-info" role="status">
+                <span class="visually-hidden">Loading...</span>
+              </div>
+              <span class="text-info fw-semibold">Parsing antenna files...</span>
+            </div>
+            <div class="row text-center mb-3">
+              <div class="col-3">
+                <div class="h4 mb-0 text-primary">{parseProgress.directoriesScanned}</div>
+                <small class="text-muted">Folders</small>
+              </div>
+              <div class="col-3">
+                <div class="h4 mb-0 text-info">{parseProgress.filesProcessed}</div>
+                <small class="text-muted">Processed</small>
+              </div>
+              <div class="col-3">
+                <div class="h4 mb-0 text-success">{parseProgress.antennaFilesFound}</div>
+                <small class="text-muted">Parsed</small>
+              </div>
+              <div class="col-3">
+                <div class="h4 mb-0 {parseProgress.failedFiles > 0 ? 'text-danger' : 'text-muted'}">{parseProgress.failedFiles}</div>
+                <small class="text-muted">Failed</small>
+              </div>
+            </div>
+            <div class="text-muted small text-truncate">
+              <i class="bi bi-file-earmark me-1"></i>
+              {parseProgress.currentFile}
+            </div>
+          </div>
+        </div>
+      {/if}
+
+      {#if message && !error && !parseProgress}
         <div class="alert alert-info border-0 bg-info-subtle text-info-emphasis" role="alert">
           <i class="bi bi-info-circle me-2"></i>
           {message}
         </div>
       {/if}
 
+      <!-- Parse Errors Summary -->
+      {#if parseErrors.length > 0 && !parseProgress}
+        <div class="alert alert-warning border-0 bg-warning-subtle" role="alert">
+          <div class="d-flex justify-content-between align-items-center">
+            <div>
+              <i class="bi bi-exclamation-triangle me-2"></i>
+              <strong>{parseErrors.length} file(s) failed to parse</strong>
+              <span class="text-muted ms-2">- Import continued with remaining files</span>
+            </div>
+            <button 
+              class="btn btn-sm btn-outline-warning" 
+              onclick={() => showErrorDetails = !showErrorDetails}
+            >
+              {showErrorDetails ? 'Hide' : 'Show'} details
+            </button>
+          </div>
+          
+          {#if showErrorDetails}
+            <hr class="my-2">
+            <div class="small" style="max-height: 200px; overflow-y: auto;">
+              <table class="table table-sm table-borderless mb-0">
+                <thead>
+                  <tr>
+                    <th style="width: 60px;">Type</th>
+                    <th>Path</th>
+                    <th>Error</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {#each parseErrors as parseError}
+                    <tr>
+                      <td>
+                        {#if parseError.type === 'folder'}
+                          <span class="badge bg-secondary"><i class="bi bi-folder"></i></span>
+                        {:else}
+                          <span class="badge bg-danger"><i class="bi bi-file-earmark"></i></span>
+                        {/if}
+                      </td>
+                      <td class="text-truncate" style="max-width: 300px;" title={parseError.path}>
+                        {parseError.path}
+                      </td>
+                      <td class="text-muted">{parseError.message}</td>
+                    </tr>
+                  {/each}
+                </tbody>
+              </table>
+            </div>
+          {/if}
+        </div>
+      {/if}
+
       {#if error}
         <div class="alert alert-danger border-0 bg-danger-subtle text-danger-emphasis" role="alert">
           <i class="bi bi-exclamation-octagon me-2"></i>

package/dist/apps/antenna-tools/components/MSIConverter.svelte.d.ts

@@ -1,5 +1,8 @@
+import type { BandDefinition } from '../types';
 interface Props {
     onDataRefresh?: () => void;
+    /** Custom band definitions for purge (defaults to STANDARD_BANDS) */
+    customBands?: BandDefinition[];
 }
 declare const MsiConverter: import("svelte").Component<Props, {}, "">;
 type MsiConverter = ReturnType<typeof MsiConverter>;

package/dist/apps/antenna-tools/types.d.ts

@@ -6,7 +6,7 @@
  * Frequency band definition for filtering antennas
  */
 export interface BandDefinition {
-    /** Simple band name: "700", "800", "900", "1800", "2100", "2600" */
+    /** Simple band name: "700", "800", "900", "1800", "2100", "2600", "3500" */
     name: string;
     /** Downlink minimum frequency (MHz) */
     dlMin: number;
@@ -14,8 +14,13 @@ export interface BandDefinition {
     dlMax: number;
 }
 /**
- * Standard frequency bands - fixed preset
- * Only downlink frequencies are considered
+ * Standard frequency bands with FULL downlink ranges per 3GPP standards
+ * These are the complete DL frequency ranges, not narrow slices
+ *
+ * References:
+ * - 3GPP TS 36.101 (LTE)
+ * - 3GPP TS 38.101 (5G NR)
+ * - ETSI standards for GSM
  */
 export declare const STANDARD_BANDS: BandDefinition[];
 /**

package/dist/apps/antenna-tools/types.js

@@ -3,14 +3,20 @@
  * Clean, centralized type definitions for the antenna-tools module
  */
 /**
- * Standard frequency bands - fixed preset
- * Only downlink frequencies are considered
+ * Standard frequency bands with FULL downlink ranges per 3GPP standards
+ * These are the complete DL frequency ranges, not narrow slices
+ *
+ * References:
+ * - 3GPP TS 36.101 (LTE)
+ * - 3GPP TS 38.101 (5G NR)
+ * - ETSI standards for GSM
  */
 export const STANDARD_BANDS = [
-    { name: '700', dlMin: 758, dlMax: 768 }, // LTE B28
-    { name: '800', dlMin: 791, dlMax: 801 }, // LTE B20
-    { name: '900', dlMin: 935, dlMax: 960 }, // GSM 900
-    { name: '1800', dlMin: 1805, dlMax: 1880 }, // GSM 1800 / LTE B3
-    { name: '2100', dlMin: 2110, dlMax: 2170 }, // LTE B1
-    { name: '2600', dlMin: 2620, dlMax: 2690 }, // LTE B7
+    { name: '700', dlMin: 758, dlMax: 803 }, // LTE B28 (APT 700) - Full DL: 758-803 MHz
+    { name: '800', dlMin: 791, dlMax: 862 }, // LTE B20 (EU 800) - Full DL: 791-862 MHz
+    { name: '900', dlMin: 925, dlMax: 960 }, // GSM 900 / LTE B8 - Full DL: 925-960 MHz
+    { name: '1800', dlMin: 1805, dlMax: 1880 }, // GSM 1800 / LTE B3 - Full DL: 1805-1880 MHz
+    { name: '2100', dlMin: 2110, dlMax: 2170 }, // LTE B1 / UMTS - Full DL: 2110-2170 MHz
+    { name: '2600', dlMin: 2620, dlMax: 2690 }, // LTE B7 - Full DL: 2620-2690 MHz
+    { name: '3500', dlMin: 3400, dlMax: 3800 }, // 5G NR n78 (C-Band) - Full: 3400-3800 MHz
 ];

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

@@ -2,7 +2,7 @@
  * Antenna Tools - Database Utilities
  * CRUD operations for antenna data with automatic purge on import
  */
-import type { Antenna, RawAntenna } from '../types';
+import type { Antenna, RawAntenna, BandDefinition } from '../types';
 import { type PurgeStats } from '../band-config';
 /**
  * Load all antennas from database
@@ -25,9 +25,10 @@ export interface ImportResult {
  * 3. Saves purged antennas to database
  *
  * @param rawAntennas - Antennas parsed from MSI files
+ * @param customBands - Optional custom band definitions (defaults to STANDARD_BANDS)
  * @returns Import result with purge statistics
  */
-export declare function saveAntennasWithPurge(rawAntennas: RawAntenna[]): Promise<ImportResult>;
+export declare function saveAntennasWithPurge(rawAntennas: RawAntenna[], customBands?: BandDefinition[]): Promise<ImportResult>;
 /**
  * Save antennas directly (without purge) - for pre-purged data
  */

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

@@ -52,13 +52,14 @@ export async function loadAntennas() {
  * 3. Saves purged antennas to database
  *
  * @param rawAntennas - Antennas parsed from MSI files
+ * @param customBands - Optional custom band definitions (defaults to STANDARD_BANDS)
  * @returns Import result with purge statistics
  */
-export async function saveAntennasWithPurge(rawAntennas) {
+export async function saveAntennasWithPurge(rawAntennas, customBands) {
     try {
         trackDataOperation('import', { inProgress: true, message: 'Purging frequencies...' });
         // Step 1: Purge - keep only one antenna per band
-        const purgedAntennas = purgeAntennas(rawAntennas);
+        const purgedAntennas = purgeAntennas(rawAntennas, customBands);
         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...` });

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

@@ -12,10 +12,58 @@ import type { RawAntenna } from '../types';
  * @returns Parsed antenna with actual MHz frequency
  */
 export declare function parseMSIFile(file: File): Promise<RawAntenna>;
+/**
+ * Progress information during folder parsing
+ */
+export interface ParseProgress {
+    /** Current file being processed */
+    currentFile: string;
+    /** Number of files processed so far */
+    filesProcessed: number;
+    /** Number of directories scanned */
+    directoriesScanned: number;
+    /** Number of MSI/PNT files found */
+    antennaFilesFound: number;
+    /** Number of files that failed to parse */
+    failedFiles: number;
+}
+/**
+ * Error information for failed file/folder parsing
+ */
+export interface ParseError {
+    /** Path to the file or folder that failed */
+    path: string;
+    /** Error message */
+    message: string;
+    /** Type of error */
+    type: 'file' | 'folder';
+}
+/**
+ * Result of folder parsing including errors
+ */
+export interface ParseFolderResult {
+    /** Successfully parsed antennas */
+    antennas: RawAntenna[];
+    /** Errors encountered during parsing */
+    errors: ParseError[];
+    /** Total files attempted */
+    totalFilesAttempted: number;
+    /** Total directories scanned */
+    totalDirectoriesScanned: number;
+}
 /**
  * Parse a folder of MSI files recursively
  * @param directoryHandle - File system directory handle
  * @param recursive - Whether to process subdirectories
- * @returns Array of parsed antennas
+ * @param onProgress - Optional callback for progress updates
+ * @returns Array of parsed antennas (for backward compatibility)
+ */
+export declare function parseFolder(directoryHandle: FileSystemDirectoryHandle, recursive?: boolean, onProgress?: (progress: ParseProgress) => void): Promise<RawAntenna[]>;
+/**
+ * Parse a folder of MSI files recursively with detailed error reporting
+ * @param directoryHandle - File system directory handle
+ * @param recursive - Whether to process subdirectories
+ * @param onProgress - Optional callback for progress updates
+ * @returns Object containing parsed antennas and any errors encountered
  */
-export declare function parseFolder(directoryHandle: FileSystemDirectoryHandle, recursive?: boolean): Promise<RawAntenna[]>;
+export declare function parseFolderWithErrors(directoryHandle: FileSystemDirectoryHandle, recursive?: boolean, onProgress?: (progress: ParseProgress) => void): Promise<ParseFolderResult>;

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

@@ -173,43 +173,126 @@ export async function parseMSIFile(file) {
  * Parse a folder of MSI files recursively
  * @param directoryHandle - File system directory handle
  * @param recursive - Whether to process subdirectories
- * @returns Array of parsed antennas
+ * @param onProgress - Optional callback for progress updates
+ * @returns Array of parsed antennas (for backward compatibility)
  */
-export async function parseFolder(directoryHandle, recursive = true) {
+export async function parseFolder(directoryHandle, recursive = true, onProgress) {
+    const result = await parseFolderWithErrors(directoryHandle, recursive, onProgress);
+    return result.antennas;
+}
+/**
+ * Parse a folder of MSI files recursively with detailed error reporting
+ * @param directoryHandle - File system directory handle
+ * @param recursive - Whether to process subdirectories
+ * @param onProgress - Optional callback for progress updates
+ * @returns Object containing parsed antennas and any errors encountered
+ */
+export async function parseFolderWithErrors(directoryHandle, recursive = true, onProgress) {
     const antennas = [];
+    const errors = [];
+    let filesProcessed = 0;
+    let directoriesScanned = 0;
+    let failedFiles = 0;
     // 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);
+        directoriesScanned++;
+        let iterator;
+        try {
+            iterator = dirHandle.values();
+        }
+        catch (error) {
+            const dirPath = path || dirHandle.name;
+            errors.push({
+                path: dirPath,
+                message: error instanceof Error ? error.message : 'Failed to read directory',
+                type: 'folder'
+            });
+            console.error(`Error reading directory ${dirPath}:`, error);
+            return; // Skip this directory but continue with others
+        }
+        try {
+            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') {
+                            filesProcessed++;
+                            const currentPath = path ? `${path}/${file.name}` : file.name;
+                            // Report progress
+                            onProgress?.({
+                                currentFile: currentPath,
+                                filesProcessed,
+                                directoriesScanned,
+                                antennaFilesFound: antennas.length,
+                                failedFiles
+                            });
+                            try {
+                                const antenna = await parseMSIFile(file);
+                                // Add the path info to help identify where the file was found
+                                antenna.sourcePath = currentPath;
+                                antennas.push(antenna);
+                            }
+                            catch (parseError) {
+                                failedFiles++;
+                                errors.push({
+                                    path: currentPath,
+                                    message: parseError instanceof Error ? parseError.message : 'Failed to parse file',
+                                    type: 'file'
+                                });
+                                console.error(`Error parsing file ${currentPath}:`, parseError);
+                                // Continue with next file
+                            }
                         }
                     }
+                    catch (fileError) {
+                        const filePath = path ? `${path}/${entry.name}` : entry.name;
+                        failedFiles++;
+                        errors.push({
+                            path: filePath,
+                            message: fileError instanceof Error ? fileError.message : 'Failed to access file',
+                            type: 'file'
+                        });
+                        console.error(`Error accessing file ${filePath}:`, fileError);
+                        // Continue with next file
+                    }
                 }
-                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;
+                    try {
+                        await processDirectory(entry, subDirPath);
+                    }
+                    catch (subDirError) {
+                        errors.push({
+                            path: subDirPath,
+                            message: subDirError instanceof Error ? subDirError.message : 'Failed to process subdirectory',
+                            type: 'folder'
+                        });
+                        console.error(`Error processing subdirectory ${subDirPath}:`, subDirError);
+                        // Continue with next entry
+                    }
                 }
             }
-            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);
-            }
+        }
+        catch (iterError) {
+            const dirPath = path || dirHandle.name;
+            errors.push({
+                path: dirPath,
+                message: iterError instanceof Error ? iterError.message : 'Error iterating directory contents',
+                type: 'folder'
+            });
+            console.error(`Error iterating directory ${dirPath}:`, iterError);
+            // Continue - the directory iteration failed but we can still return what we have
         }
     }
     await processDirectory(directoryHandle);
-    return antennas;
+    return {
+        antennas,
+        errors,
+        totalFilesAttempted: filesProcessed,
+        totalDirectoriesScanned: directoriesScanned
+    };
 }

package/dist/apps/index.d.ts

@@ -2,4 +2,6 @@ export * from './antenna-pattern/index.js';
 export { default as AntennaTools } from './antenna-tools/components/AntennaTools.svelte';
 export { default as AntennaDatabaseModal } from './antenna-tools/components/AntennaSettingsModal.svelte';
 export { default as AntennaDatabaseViewer } from './antenna-tools/components/DatabaseViewer.svelte';
+export type { BandDefinition, Antenna, RawAntenna, ExternalAntennaInput } from './antenna-tools/types.js';
+export { STANDARD_BANDS } from './antenna-tools/types.js';
 export * from './site-check/index.js';

package/dist/apps/index.js

@@ -7,6 +7,7 @@ export * from './antenna-pattern/index.js';
 export { default as AntennaTools } from './antenna-tools/components/AntennaTools.svelte';
 export { default as AntennaDatabaseModal } from './antenna-tools/components/AntennaSettingsModal.svelte';
 export { default as AntennaDatabaseViewer } from './antenna-tools/components/DatabaseViewer.svelte';
+export { STANDARD_BANDS } from './antenna-tools/types.js';
 // Test app (if needed for demos)
 // export * from './test/index.js';
 export * from './site-check/index.js';