Prevent dangling file handles.

src/modules/candidateGenerator.ts

@@ -78,7 +78,7 @@ export default class CandidateGenerator {
         }
       }
 
-      await this.progressBar.logInfo(`${dat.getName()}: Found ${releaseCandidates.length} candidates for ${parent}`);
+      await this.progressBar.logDebug(`${dat.getName()}: Found ${releaseCandidates.length} candidates for ${parent.getName()}`);
       output.set(parent, releaseCandidates);
     }
 

src/modules/datScanner.ts

@@ -65,20 +65,20 @@ export default class DATScanner extends Scanner {
     return results.sort((a, b) => a.getNameShort().localeCompare(b.getNameShort()));
   }
 
-  private async parseDatFile(datFile: File): Promise<DataFile | void> {
-    try {
-      await this.progressBar.logDebug(`${datFile.toString()}: parsing XML`);
-      return await datFile.extractToStream(async (stream) => {
+  private async parseDatFile(datFile: File): Promise<DataFile | undefined> {
+    await this.progressBar.logDebug(`${datFile.toString()}: parsing XML`);
+    return datFile.extractToStream(async (stream) => {
+      try {
         const xmlContents = await bufferPoly.fromReadable(stream);
-        return xml2js.parseStringPromise(xmlContents.toString(), {
+        return await xml2js.parseStringPromise(xmlContents.toString(), {
           mergeAttrs: true,
           explicitArray: false,
         });
-      });
-    } catch (err) {
-      const message = (err as Error).message.split('\n').join(', ');
-      await this.progressBar.logError(`Failed to parse DAT ${datFile.toString()} : ${message}`);
-      return Promise.resolve();
-    }
+      } catch (e) {
+        const message = (e as Error).message.split('\n').join(', ');
+        await this.progressBar.logError(`Failed to parse DAT ${datFile.toString()} : ${message}`);
+        return undefined;
+      }
+    });
   }
 }

src/modules/outputCleaner.ts

@@ -50,24 +50,31 @@ export default class OutputCleaner {
     await this.progressBar.reset(filesToClean.length);
 
     try {
-      await OutputCleaner.trashOrDelete(filesToClean);
+      await this.progressBar.logInfo(`Cleaning ${filesToClean.length.toLocaleString()} files`);
+      await this.trashOrDelete(filesToClean);
     } catch (e) {
       await this.progressBar.logError(`Failed to clean unmatched files in ${outputDir} : ${e}`);
     }
 
     try {
       const emptyDirs = await OutputCleaner.getEmptyDirs(outputDir);
-      await OutputCleaner.trashOrDelete(emptyDirs);
+      await this.progressBar.logInfo(`Cleaning ${emptyDirs.length.toLocaleString()} empty directories`);
+      await this.trashOrDelete(emptyDirs);
     } catch (e) {
       await this.progressBar.logError(`Failed to clean empty directories in ${outputDir} : ${e}`);
     }
 
     return filesToClean.length;
   }
 
-  private static async trashOrDelete(filePaths: string[]): Promise<void> {
+  private async trashOrDelete(filePaths: string[]): Promise<void> {
     // Prefer recycling...
-    await trash(filePaths);
+    const CHUNK_SIZE = 100;
+    /* eslint-disable no-await-in-loop */
+    for (let i = 0; i < filePaths.length; i += CHUNK_SIZE) {
+      await this.progressBar.update(i);
+      await trash(filePaths.slice(i, i + CHUNK_SIZE));
+    }
 
     // ...but if that doesn't work, delete the leftovers
     await Promise.all(filePaths.map(async (filePath) => {

src/types/archives/zip.ts

@@ -80,6 +80,7 @@ export default class Zip extends Archive {
             return reject(callbackErr);
           }
         });
+        writeStream.on('error', (err) => reject(err));
         readStream.pipe(writeStream);
       }),
     );

src/types/files/file.ts

@@ -151,9 +151,11 @@ export default class File {
       `${path.basename(this.getFilePath())}.temp`,
     ));
     await fsPromises.copyFile(this.getFilePath(), temp);
-    const result = await callback(temp);
-    await fsPoly.rm(temp);
-    return result;
+    try {
+      return await callback(temp);
+    } finally {
+      await fsPoly.rm(temp);
+    }
   }
 
   async extractToStream<T>(
@@ -180,9 +182,11 @@ export default class File {
     callback: (stream: Readable) => (Promise<T> | T),
   ): Promise<T> {
     const stream = fs.createReadStream(filePath, { start });
-    const result = await callback(stream);
-    stream.destroy();
-    return result;
+    try {
+      return await callback(stream);
+    } finally {
+      stream.destroy();
+    }
   }
 
   async withFileName(fileNameWithoutExt: string): Promise<File> {

src/types/patches/bpsPatch.ts

@@ -63,6 +63,7 @@ export default class BPSPatch extends Patch {
       // Skip header info
       const header = await fp.readNext(4);
       if (header.toString() !== 'BPS1') {
+        await fp.close();
         throw new Error(`BPS patch header is invalid: ${this.getFile().toString()}`);
       }
       await BPSPatch.readNumber(fp); // source size

src/types/patches/ipsPatch.ts

@@ -36,6 +36,7 @@ export default class IPSPatch extends Patch {
 
       const header = (await fp.readNext(5)).toString();
       if (header !== 'PATCH') {
+        await fp.close();
         throw new Error(`IPS patch header is invalid: ${this.getFile().toString()}`);
       }
 

src/types/patches/ppfPatch.ts

@@ -29,11 +29,13 @@ export default class PPFPatch extends Patch {
 
       const header = (await fp.readNext(5)).toString();
       if (!header.startsWith('PPF')) {
+        await fp.close();
         throw new Error(`PPF patch header is invalid: ${this.getFile().toString()}`);
       }
       const encoding = (await fp.readNext(1))[0];
       const version = encoding + 1;
       if (!header.endsWith(`${version}0`)) {
+        await fp.close();
         throw new Error(`PPF patch header is invalid: ${this.getFile().toString()}`);
       }
 
@@ -50,6 +52,7 @@ export default class PPFPatch extends Patch {
         undoDataAvailable = (await fp.readNext(1)).readUInt8() === 0x01;
         await fp.readNext(1); // dummy
       } else {
+        await fp.close();
         throw new Error(`PPF v${version} isn't supported: ${this.getFile().toString()}`);
       }