1 files changed, 67 insertions, 63 deletions

diff --git a/src/file-size-preloader.js b/src/file-size-preloader.js
index d0807cc..4eadde7 100644
--- a/src/file-size-preloader.js
+++ b/src/file-size-preloader.js
@@ -17,84 +17,88 @@
 // This only processes files one at a time because I'm lazy and stat calls
 // are very, very fast.
 
-import { stat } from 'fs/promises';
-import { logWarn } from './util/cli.js';
+import {stat} from 'node:fs/promises';
 
-export default class FileSizePreloader {
-    #paths = [];
-    #sizes = [];
-    #loadedPathIndex = -1;
-
-    #loadingPromise = null;
-    #resolveLoadingPromise = null;
+import {logWarn} from '#cli';
 
-    loadPaths(...paths) {
-        this.#paths.push(...paths.filter(p => !this.#paths.includes(p)));
-        return this.#startLoadingPaths();
-    }
+export default class FileSizePreloader {
+  #paths = [];
+  #sizes = [];
+  #loadedPathIndex = -1;
 
-    waitUntilDoneLoading() {
-        return this.#loadingPromise ?? Promise.resolve();
-    }
+  #loadingPromise = null;
+  #resolveLoadingPromise = null;
 
-    #startLoadingPaths() {
-        if (this.#loadingPromise) {
-            return this.#loadingPromise;
-        }
+  hadErrored = false;
 
-        this.#loadingPromise = new Promise((resolve => {
-            this.#resolveLoadingPromise = resolve;
-        }));
+  loadPaths(...paths) {
+    this.#paths.push(...paths.filter((p) => !this.#paths.includes(p)));
+    return this.#startLoadingPaths();
+  }
 
-        this.#loadNextPath();
+  waitUntilDoneLoading() {
+    return this.#loadingPromise ?? Promise.resolve();
+  }
 
-        return this.#loadingPromise;
+  #startLoadingPaths() {
+    if (this.#loadingPromise) {
+      return this.#loadingPromise;
     }
 
-    async #loadNextPath() {
-        if (this.#loadedPathIndex === this.#paths.length - 1) {
-            return this.#doneLoadingPaths();
-        }
+    this.#loadingPromise = new Promise((resolve) => {
+      this.#resolveLoadingPromise = resolve;
+    });
 
-        let size;
+    this.#loadNextPath();
 
-        const path = this.#paths[this.#loadedPathIndex + 1];
+    return this.#loadingPromise;
+  }
 
-        try {
-            size = await this.readFileSize(path);
-        } catch (error) {
-            // Oops! Discard that path, and don't increment the index before
-            // moving on, since the next path will now be in its place.
-            this.#paths.splice(this.#loadedPathIndex + 1, 1);
-            logWarn`Failed to process file size for ${path}: ${error.message}`;
-            return this.#loadNextPath();
-        }
-
-        this.#sizes.push(size);
-        this.#loadedPathIndex++;
-        return this.#loadNextPath();
+  async #loadNextPath() {
+    if (this.#loadedPathIndex === this.#paths.length - 1) {
+      return this.#doneLoadingPaths();
     }
 
-    #doneLoadingPaths() {
-        this.#resolveLoadingPromise();
-        this.#loadingPromise = null;
-        this.#resolveLoadingPromise = null;
-    }
+    let size;
 
-    // Override me if you want?
-    // The rest of the code here is literally just a queue system, so you could
-    // pretty much repurpose it for anything... but there are probably cleaner
-    // ways than making an instance or subclass of this and overriding this one
-    // method!
-    async readFileSize(path) {
-        const stats = await stat(path);
-        return stats.size;
-    }
+    const path = this.#paths[this.#loadedPathIndex + 1];
 
-    getSizeOfPath(path) {
-        const index = this.#paths.indexOf(path);
-        if (index === -1) return null;
-        if (index > this.#loadedPathIndex) return null;
-        return this.#sizes[index];
+    try {
+      size = await this.readFileSize(path);
+    } catch (error) {
+      // Oops! Discard that path, and don't increment the index before
+      // moving on, since the next path will now be in its place.
+      this.#paths.splice(this.#loadedPathIndex + 1, 1);
+      this.hasErrored = true;
+      logWarn`Failed to process file size for ${path}: ${error.message}`;
+      return this.#loadNextPath();
     }
+
+    this.#sizes.push(size);
+    this.#loadedPathIndex++;
+    return this.#loadNextPath();
+  }
+
+  #doneLoadingPaths() {
+    this.#resolveLoadingPromise();
+    this.#loadingPromise = null;
+    this.#resolveLoadingPromise = null;
+  }
+
+  // Override me if you want?
+  // The rest of the code here is literally just a queue system, so you could
+  // pretty much repurpose it for anything... but there are probably cleaner
+  // ways than making an instance or subclass of this and overriding this one
+  // method!
+  async readFileSize(path) {
+    const stats = await stat(path);
+    return stats.size;
+  }
+
+  getSizeOfPath(path) {
+    const index = this.#paths.indexOf(path);
+    if (index === -1) return null;
+    if (index > this.#loadedPathIndex) return null;
+    return this.#sizes[index];
+  }
 }