@smartnet360/svelte-components 0.0.123 → 0.0.124

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

@@ -174,55 +174,125 @@ export async function parseMSIFile(file) {
  * @param directoryHandle - File system directory handle
  * @param recursive - Whether to process subdirectories
  * @param onProgress - Optional callback for progress updates
- * @returns Array of parsed antennas
+ * @returns Array of parsed antennas (for backward compatibility)
  */
 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 = '') {
         directoriesScanned++;
-        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') {
-                        filesProcessed++;
-                        const currentPath = path ? `${path}/${file.name}` : file.name;
-                        // Report progress
-                        onProgress?.({
-                            currentFile: currentPath,
-                            filesProcessed,
-                            directoriesScanned,
-                            antennaFilesFound: antennas.length
-                        });
-                        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 (error) {
-                            console.error(`Error parsing file ${currentPath}:`, error);
+        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
+    };
 }