funkophile 0.2.5 → 1.0.0

package/index.ts

@@ -1,446 +1,93 @@
-import chokidar from "chokidar";
-import { createSelector } from "reselect";
-import { Action, createStore, Store } from "redux";
-import fs from "fs";
-import fse from "fs-extra";
-import { glob } from "glob";
-import http from "http";
-import path from "path";
 import Promise from "bluebird";
-import url from "url";
-
-export default (funkophileConfig: {
-	mode: 'build' | 'watch';
-	initialState: any;
-	options: {
-		inFolder: string;
-		outFolder: string;
-		port?: number;
-	},
-	encodings: Record<string, string[]>,
-	inputs: Record<string, string>,
-	outputs: (x: any) => any;
-}) => {
+import fse from "fs-extra";
 
-  Promise.config({
-    cancellation: true,
-  });
+import { Action, Store } from "redux";
+import {
+  IConfig,
+  INITIALIZE,
+  cleanEmptyFoldersRecursively,
+  logDone,
+  logInputKeys,
+  logger,
+  makeFinalSelector,
+  makePromissesArray,
+  newStore,
+  previousState,
+  startServing,
+} from "./utils";
 
-  const INITIALIZE = "INITIALIZE";
-  const UPSERT = "UPSERT";
-  const REMOVE = "REMOVE";
+Promise.config({
+  cancellation: true,
+});
 
-  const previousState: any = {};
+export default (funkophileConfig: IConfig) => {
   let outputPromise = Promise.resolve();
+  const store: Store<any, Action<string>, any> = newStore(funkophileConfig);
+  const finalSelector = makeFinalSelector(funkophileConfig);
 
-  const logger = {
-    watchError: (p: string) => console.log("\u001b[7m ! \u001b[0m" + p),
-    watchReady: (p: string) =>
-      console.log("\u001b[7m\u001b[36m  <  \u001b[0m" + p),
-    watchAdd: (p: string) =>
-      console.log("\u001b[7m\u001b[34m  +  \u001b[0m./" + p),
-    watchChange: (p: string) =>
-      console.log("\u001b[7m\u001b[35m  *  \u001b[0m" + p),
-    watchUnlink: (p: string) =>
-      console.log("\u001b[7m\u001b[31m  -  \u001b[0m./" + p),
-    stateChange: () =>
-      console.log("\u001b[7m\u001b[31m --- Redux state changed --- \u001b[0m"),
-    cleaningEmptyfolder: (p: string) =>
-      console.log("\u001b[31m\u001b[7m XXX! \u001b[0m" + p),
-    readingFile: (p: string) => console.log("\u001b[31m <-- \u001b[0m" + p),
-    removedFile: (p: string) =>
-      console.log("\u001b[31m\u001b[7m ??? \u001b[0m./" + p),
-    writingString: (p: string) => console.log("\u001b[32m --> \u001b[0m" + p),
-    writingFunction: (p: string) => console.log("\u001b[33m ... \u001b[0m" + p),
-    writingPromise: (p: string) => console.log("\u001b[33m ... \u001b[0m" + p),
-    writingError: (p: string, message: string) =>
-      console.log("\u001b[31m !!! \u001b[0m" + p + " " + message),
-
-    waiting: () =>
-      console.log(
-        "\u001b[7m Funkophile is done for now but waiting on changes...\u001b[0m "
-      ),
-    done: () => console.log("\u001b[7m Funkophile is done!\u001b[0m "),
-  };
-
-  function cleanEmptyFoldersRecursively(folder: string) {
-    var isDir = fs.statSync(folder).isDirectory();
-    if (!isDir) {
-      return;
-    }
-    var files = fs.readdirSync(folder);
-    if (files.length > 0) {
-      files.forEach(function (file) {
-        var fullPath = path.join(folder, file);
-      });
-
-      // re-evaluate files; after deleting subfolder
-      // we may have parent folder empty now
-      files = fs.readdirSync(folder);
-    }
-
-    if (files.length == 0) {
-      logger.cleaningEmptyfolder(folder);
-
-      fs.rmdirSync(folder);
-      return;
-    }
-  }
-
-  const dispatchUpsert = (
-    store: Store,
-    key: string,
-    file: string,
-    encodings: Record<string, string[]>
-  ) => {
-
-    const fileType: string = path.basename(file).split(".")[1];
-
-    let encoding: BufferEncoding = Object.keys(encodings).find((e) => {
-      return encodings[e].includes(fileType);
-    }) as BufferEncoding;
-
-    logger.readingFile(file);
-    store.dispatch({
-      type: UPSERT,
-      payload: {
-				key: key,
-				// key: path.relative(process.cwd(), key),
-        src: file,
-        contents: fse.readFileSync(file, encoding),
-      },
-    });
-  };
-
-  function omit(key: string, obj: any) {
-    const { [key]: omitted, ...rest } = obj;
-    return rest;
-  }
-
-  const store: Store<any, Action<string>, any> = createStore(
-    (
-      state = {
-        initialLoad: true,
-        ...funkophileConfig.initialState,
-        timestamp: Date.now(),
-      },
-      action,
-    ) => {
-      if (state === undefined) {
-        throw new Error("Redux state is undefined. This should never happen.");
-      }
-      // console.log("\u001b[7m\u001b[35m ||| Redux recieved action \u001b[0m", action.type)
-      if (!action.type.includes("@@redux")) {
-        if (action.type === INITIALIZE) {
-          return {
-            ...state,
-            initialLoad: false,
-            timestamp: Date.now(),
-          };
-        } else if (action.type === UPSERT) {
-          return {
-            ...state,
-            [action["payload"].key]: {
-              // @ts-ignore
-              ...state[action.payload.key],
-              ...{
-                [action["payload"].src]: action["payload"].contents,
-              },
-            },
-            timestamp: Date.now(),
-          };
-        } else if (action.type === REMOVE) {
-          return {
-            ...state,
-            [action["payload"].key]: omit(
-              action["payload"].file,
-              state[action["payload"].key]
-            ),
-            timestamp: Date.now(),
-          };
-        } else {
-          console.error(
-            "Redux was asked to handle an unknown action type: " + action.type
-          );
-          process.exit(-1);
-        }
-        // return state
-      }
-    }
-  );
-
-  const finalSelector = funkophileConfig.outputs(
-    Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
-      return {
-        ...mm,
-        [inputKey]: createSelector([(x) => x], (root) => {
-          const result = root[inputKey];
-          if (result === undefined) {
-            throw new Error(
-              `Input key "${inputKey}" is undefined in state. ` +
-              `This means no files were found for the pattern "${funkophileConfig.inputs[inputKey]}". ` +
-              `Available state keys: ${Object.keys(root).join(', ')}`
-            );
-          }
-          return result;
-        }),
-      };
-    }, {})
-  );
-
-  // Start HTTP server in watch mode
-  let server: http.Server | null = null;
   if (funkophileConfig.mode === "watch") {
-    const port = funkophileConfig.options.port || 8080;
-    server = http.createServer((req, res) => {
-      if (!req.url) {
-        res.statusCode = 400;
-        res.end('Bad Request');
-        return;
-      }
-      
-      const parsedUrl = url.parse(req.url);
-      let pathname = parsedUrl.pathname;
-      
-      // Default to index.html if the path ends with /
-      if (pathname && pathname.endsWith('/')) {
-        pathname += 'index.html';
-      }
-      
-      // Remove leading slash
-      const filePath = pathname ? pathname.substring(1) : 'index.html';
-      
-      // Construct the full path to the file
-      const fullPath = path.join(process.cwd(), funkophileConfig.options.outFolder, filePath);
-      
-      // Check if file exists
-      fs.access(fullPath, fs.constants.F_OK, (err) => {
-        if (err) {
-          // Try with .html extension
-          const htmlPath = fullPath + '.html';
-          fs.access(htmlPath, fs.constants.F_OK, (htmlErr) => {
-            if (htmlErr) {
-              // File not found
-              res.statusCode = 404;
-              res.end('File not found');
-            } else {
-              // Serve the .html file
-              fs.readFile(htmlPath, (readErr, data) => {
-                if (readErr) {
-                  res.statusCode = 500;
-                  res.end('Internal Server Error');
-                } else {
-                  res.setHeader('Content-Type', 'text/html');
-                  res.end(data);
-                }
-              });
-            }
-          });
-        } else {
-          // Serve the file
-          fs.readFile(fullPath, (readErr, data) => {
-            if (readErr) {
-              res.statusCode = 500;
-              res.end('Internal Server Error');
-            } else {
-              // Set appropriate content type based on file extension
-              const ext = path.extname(fullPath).toLowerCase();
-              const contentTypes: Record<string, string> = {
-                '.html': 'text/html',
-                '.css': 'text/css',
-                '.js': 'application/javascript',
-                '.json': 'application/json',
-                '.png': 'image/png',
-                '.jpg': 'image/jpeg',
-                '.jpeg': 'image/jpeg',
-                '.gif': 'image/gif',
-                '.svg': 'image/svg+xml',
-                '.ico': 'image/x-icon'
-              };
-              res.setHeader('Content-Type', contentTypes[ext] || 'application/octet-stream');
-              res.end(data);
-            }
-          });
-        }
-      });
-    });
-    
-    server.listen(port, () => {
-      console.log(`\u001b[36m\u001b[1m[Funkophile]\u001b[0m Server running at http://localhost:${port}/`);
-    });
+    startServing(funkophileConfig);
   }
 
   // Wait for all the file watchers to check in
   Promise.all(
-    Object.keys(funkophileConfig.inputs).map((inputRuleKey) => {
-      // Ensure the pattern includes the inFolder and is relative to the current working directory
-      // Also, make sure to handle patterns that might already include the inFolder
-      const pattern = funkophileConfig.inputs[inputRuleKey] || "";
-      // For glob, we want the pattern to be relative to process.cwd()
-      // Join inFolder and pattern using forward slashes
-      const globPattern = path.posix.join(funkophileConfig.options.inFolder, pattern);
-      // console.log(`[Funkophile] Looking for files with glob pattern: ${globPattern}`);
-      // console.log(`[Funkophile] Current working directory: ${process.cwd()}`);
-
-      return new Promise((fulfill, reject) => {
-        if (funkophileConfig.mode === "build") {
-          // Use the glob pattern we constructed earlier
-          // console.log(`[Funkophile] Searching for files matching pattern: ${globPattern}`);
-          // console.log(`[Funkophile] Input rule key: ${inputRuleKey}`);
-          
-          glob(globPattern, { cwd: process.cwd() })
-            .then((files: string[]) => {
-              // console.log(`[Funkophile] Found ${files.length} files for ${inputRuleKey} (pattern: ${pattern}):`, files);
-              if (files.length === 0) {
-                console.warn(`No files found for input key "${inputRuleKey}" with pattern "${globPattern}"`);
-                // console.log(`[Funkophile] The glob pattern used was: ${globPattern}`);
-              } else {
-                files.forEach((file) => {
-                  // Make sure the file path is absolute
-                  const absoluteFilePath = path.resolve(process.cwd(), file);
-                  // console.log(`[Funkophile] Adding file to state for key ${inputRuleKey}: ${absoluteFilePath}`);
-                  dispatchUpsert(
-                    store,
-                    inputRuleKey,
-                    absoluteFilePath,
-                    funkophileConfig.encodings
-                  );
-                });
-              }
-            })
-            .then(() => {
-              fulfill();
-            })
-            .catch((error) => {
-              // console.error(`[Funkophile] Error globbing for pattern ${globPattern}:`, error);
-              reject(error);
-            });
-        } else if (funkophileConfig.mode === "watch") {
-          // Use the same glob pattern for watch mode
-          // console.log(`[Funkophile] Watching for files matching pattern: ${globPattern}`);
-          
-          // First, use glob to find existing files to ensure they're added to the state
-          glob(globPattern, { cwd: process.cwd() })
-            .then((files: string[]) => {
-              // console.log(`[Funkophile] Found ${files.length} existing files for ${inputRuleKey} (pattern: ${pattern}):`, files);
-              files.forEach((file) => {
-                const absoluteFilePath = path.resolve(process.cwd(), file);
-                // console.log(`[Funkophile] Adding existing file to state for key ${inputRuleKey}: ${absoluteFilePath}`);
-                dispatchUpsert(
-                  store,
-                  inputRuleKey,
-                  absoluteFilePath,
-                  funkophileConfig.encodings
-                );
-              });
-              
-              // Now set up the watcher
-              const watcher = chokidar
-                .watch(globPattern, { 
-                  cwd: process.cwd(),
-                  ignoreInitial: true // We've already handled initial files above
-                })
-                .on("error", (error) => {
-                  logger.watchError(globPattern);
-                })
-                .on("ready", () => {
-                  logger.watchReady(globPattern);
-                  fulfill();
-                })
-                .on("add", (filePath) => {
-                  logger.watchAdd(filePath);
-                  const absoluteFilePath = path.resolve(process.cwd(), filePath);
-                  dispatchUpsert(
-                    store,
-                    inputRuleKey,
-                    absoluteFilePath,
-                    funkophileConfig.encodings
-                  );
-                })
-                .on("change", (filePath) => {
-                  logger.watchChange(filePath);
-                  const absoluteFilePath = path.resolve(process.cwd(), filePath);
-                  dispatchUpsert(
-                    store,
-                    inputRuleKey,
-                    absoluteFilePath,
-                    funkophileConfig.encodings
-                  );
-                })
-                .on("unlink", (filePath) => {
-                  logger.watchUnlink(filePath);
-                  const absoluteFilePath = path.resolve(process.cwd(), filePath);
-                  store.dispatch({
-                    type: REMOVE,
-                    payload: {
-                      key: inputRuleKey,
-                      file: absoluteFilePath,
-                    },
-                  });
-                })
-                .on("unlinkDir", (filePath) => {
-                  logger.watchUnlink(filePath);
-                });
-            })
-            .catch((error) => {
-              console.error(`[Funkophile] Error globbing for pattern ${globPattern}:`, error);
-              reject(error);
-            });
-          // .on('raw', (event, p, details) => { // internal
-          //   log('Raw event info:', event, p, details);
-          // })
-        } else {
-          console.error(
-            `mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
-          );
-          process.exit(-1);
-        }
-      });
-    })
+    makePromissesArray(funkophileConfig, store)
   ).then(function () {
-    // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m All input files processed. Setting up store subscription...');
-    
-    // Debug: log the current state after all files are processed
-    const currentState = store.getState();
-    console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Current state keys:', Object.keys(currentState));
-    // Log all input keys to see if they're present
-    Object.keys(funkophileConfig.inputs).forEach(inputKey => {
-      if (currentState[inputKey]) {
-        // console.log(`[Funkophile] Input key "${inputKey}" found in state with ${Object.keys(currentState[inputKey]).length} files`);
-      } else {
-        throw(`Input key "${inputKey}" NOT found in state`);
-      }
-    });
-    
-    // listen for changes to the store
+    console.log(
+      "\u001b[32m\u001b[1m[Funkophile]\u001b[0m All input watchers are ready. Setting up store subscription..."
+    );
+
+    // Set up the store subscription BEFORE initializing to catch all changes
     store.subscribe(() => {
       const s = store.getState();
-      
+      console.log(
+        `\u001b[36m\u001b[1m[Funkophile]\u001b[0m Store updated. initialLoad: ${s.initialLoad}, timestamp: ${s.timestamp}`
+      );
+
       // Skip processing during initial load
       if (s.initialLoad) {
-        console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Initial load in progress, skipping processing...');
-        console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m State keys during initial load:', Object.keys(s));
+        console.log(
+          "\u001b[36m\u001b[1m[Funkophile]\u001b[0m Initial load in progress, skipping processing..."
+        );
+        console.log(
+          "\u001b[36m\u001b[1m[Funkophile]\u001b[0m State keys during initial load:",
+          Object.keys(s)
+        );
         return;
       }
 
       logger.stateChange();
-      console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Processing state changes...');
-      
+      console.log(
+        "\u001b[36m\u001b[1m[Funkophile]\u001b[0m Processing state changes..."
+      );
+      console.log(
+        "\u001b[36m\u001b[1m[Funkophile]\u001b[0m Current state keys:",
+        Object.keys(s)
+      );
+
       let outputs;
       try {
         outputs = finalSelector(s);
-        console.log(`\u001b[36m\u001b[1m[Funkophile]\u001b[0m Generated ${Object.keys(outputs).length} outputs`);
+        console.log(
+          `\u001b[36m\u001b[1m[Funkophile]\u001b[0m Generated ${
+            Object.keys(outputs).length
+          } outputs`
+        );
       } catch (error) {
-        console.error('\u001b[31m\u001b[1m[Funkophile]\u001b[0m FATAL: Error in output selector chain:');
-        console.error('  Error:', error.message);
-        console.error('  Stack:', error.stack);
+        console.error(
+          "\u001b[31m\u001b[1m[Funkophile]\u001b[0m FATAL: Error in output selector chain ? :"
+        );
+        console.error("  Error:", error.message);
+        console.error("  Stack:", error.stack);
         // Don't exit the process in watch mode, just log the error and continue
-        if (funkophileConfig.mode === 'build') {
+        if (funkophileConfig.mode === "build") {
           process.exit(1);
         } else {
-          console.log('\u001b[33m\u001b[1m[Funkophile]\u001b[0m Continuing to watch for changes despite error...');
+          console.log(
+            "\u001b[33m\u001b[1m[Funkophile]\u001b[0m Continuing to watch for changes despite error..."
+          );
           // Reset previousState to empty to ensure we try processing again on next change
-          Object.keys(previousState).forEach(key => {
+          Object.keys(previousState).forEach((key) => {
             delete previousState[key];
           });
           return;
@@ -448,7 +95,9 @@ export default (funkophileConfig: {
       }
 
       if (outputPromise.isPending()) {
-        console.log("\u001b[33m\u001b[1m[Funkophile]\u001b[0m Cancelling previous write operation!");
+        console.log(
+          "\u001b[33m\u001b[1m[Funkophile]\u001b[0m Cancelling previous write operation!"
+        );
         outputPromise.cancel();
       }
 
@@ -460,7 +109,9 @@ export default (funkophileConfig: {
             if (!outputs[key]) {
               const file = funkophileConfig.options.outFolder + "/" + key;
               logger.removedFile(file);
-              console.log(`\u001b[31m\u001b[1m[Funkophile]\u001b[0m Removing file: ${file}`);
+              console.log(
+                `\u001b[31m\u001b[1m[Funkophile]\u001b[0m Removing file: ${file}`
+              );
 
               try {
                 fse.unlinkSync("./" + file);
@@ -469,7 +120,10 @@ export default (funkophileConfig: {
                 );
               } catch (ex) {
                 // Log error but don't fail the entire process
-                console.error(`\u001b[31m\u001b[1m[Funkophile]\u001b[0m Error removing file ${file}:`, ex.message);
+                console.error(
+                  `\u001b[31m\u001b[1m[Funkophile]\u001b[0m Error removing file ${file}:`,
+                  ex.message
+                );
               } finally {
                 delete previousState[key];
                 fulfill();
@@ -483,7 +137,7 @@ export default (funkophileConfig: {
                 const contents = outputs[key];
 
                 // console.log(`\u001b[32m\u001b[1m[Funkophile]\u001b[0m Writing file: ${relativeFilePath}`);
-                
+
                 if (typeof contents === "function") {
                   logger.writingFunction(relativeFilePath);
                   contents((err, res) => {
@@ -586,42 +240,36 @@ export default (funkophileConfig: {
         // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Cleaning empty folders...');
         cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
 
-        if (funkophileConfig.mode === "build") {
-          console.log('\u001b[32m\u001b[1m[Funkophile]\u001b[0m Build completed successfully!');
-          logger.done();
-        } else if (funkophileConfig.mode === "watch") {
-          console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Watching for file changes...');
-          // Log the localhost URL if port is specified
-          const port = funkophileConfig.options.port || 8080;
-          console.log(`\u001b[36m\u001b[1m[Funkophile]\u001b[0m Serving at: http://localhost:${port}/`);
-          logger.waiting();
-        } else {
-          throw (
-            `\u001b[31m\u001b[1m[Funkophile]\u001b[0m The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
-          );
-
-        }
-      })
+        logDone(funkophileConfig, currentState) 
+      });
       //   .catch((error) => {
       //   // console.error('\u001b[31m\u001b[1m[Funkophile]\u001b[0m Error during file operations:', error);
       // });
     });
 
-    // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Initializing store...');
-    // lastly, turn the store `on`.
-    // This is to prevent unecessary recomputations when initialy adding files to redux
-    store.dispatch({
-      type: INITIALIZE,
-      payload: true,
-    });
-    // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Store initialized. Starting processing...');
-  });
+    console.log(
+      "\u001b[32m\u001b[1m[Funkophile]\u001b[0m Dispatching INITIALIZE action to enable processing..."
+    );
+    // Debug: log the current state after all files are processed
+    const currentState = store.getState();
+    console.log(
+      "\u001b[36m\u001b[1m[Funkophile]\u001b[0m Current state keys:",
+      Object.keys(currentState)
+    );
+
+    logInputKeys(funkophileConfig, currentState);
 
-  // Handle process exit to close the server
-  process.on('SIGINT', () => {
-    if (server) {
-      server.close();
-    }
-    process.exit(0);
+    // Add a small delay to ensure all file operations are complete before initializing
+    setTimeout(() => {
+      // lastly, turn the store `on`.
+      // This is to prevent unecessary recomputations when initialy adding files to redux
+      store.dispatch({
+        type: INITIALIZE,
+        payload: true,
+      });
+      console.log(
+        "\u001b[32m\u001b[1m[Funkophile]\u001b[0m Store initialized. Ready to process changes!"
+      );
+    }, 100);
   });
 };

package/mocha.log

@@ -0,0 +1,59 @@
+warning ../../package.json: No license field
+$ mocha --loader=ts '**/*.test.ts'
+
+
+  Funkophile Core
+    makeStore
+      ✔ should create a store with empty state until it is initialized
+    omit
+      ✔ should remove the specified key from object
+    selectors
+      for the pages
+        ✔ contentsOfFiles should concatenate all file contents
+        ✔ contentOfFile should return first file content
+        ✔ srcAndContentOfFile should return src and content
+        ✔ srcAndContentOfFiles should return array of src/content pairs
+      for the posts
+        ✔ contentsOfFiles should concatenate all file contents
+        ✔ contentOfFile should return first file content
+        ✔ srcAndContentOfFile should return src and content
+        ✔ srcAndContentOfFiles should return array of src/content pairs
+    createInputSelectors
+      ✔ should create a selector for each input key
+      ✔ selectors should return the corresponding state slice
+    store actions
+      ✔ should handle INITIALIZE action
+      ✔ should handle UPSERT action
+      ✔ should handle REMOVE action
+    edge cases
+An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)` {
+  arguments: [Arguments] {
+    '0': { timestamp: 1752731765346, posts: [Object], pages: [Object] }
+  },
+  firstInputs: [ {} ],
+  secondInputs: [ {} ],
+  stack: 'Error\n' +
+    '    at Object.runInputStabilityCheck (/Users/adam/Code/funkophile/node_modules/reselect/src/devModeChecks/inputStabilityCheck.ts:41:13)\n' +
+    '    at dependenciesChecker (/Users/adam/Code/funkophile/node_modules/reselect/src/createSelectorCreator.ts:432:31)\n' +
+    '    at memoized (/Users/adam/Code/funkophile/node_modules/reselect/src/weakMapMemoize.ts:228:21)\n' +
+    '    at Context.<anonymous> (/Users/adam/Code/funkophile/index.test.ts:193:14)\n' +
+    '    at callFn (/Users/adam/Code/funkophile/node_modules/mocha/lib/runnable.js:366:21)\n' +
+    '    at Runnable.run (/Users/adam/Code/funkophile/node_modules/mocha/lib/runnable.js:354:5)\n' +
+    '    at Runner.runTest (/Users/adam/Code/funkophile/node_modules/mocha/lib/runner.js:715:10)\n' +
+    '    at /Users/adam/Code/funkophile/node_modules/mocha/lib/runner.js:838:12\n' +
+    '    at next (/Users/adam/Code/funkophile/node_modules/mocha/lib/runner.js:630:14)\n' +
+    '    at /Users/adam/Code/funkophile/node_modules/mocha/lib/runner.js:640:7\n' +
+    '    at next (/Users/adam/Code/funkophile/node_modules/mocha/lib/runner.js:523:14)\n' +
+    '    at Immediate._onImmediate (/Users/adam/Code/funkophile/node_modules/mocha/lib/runner.js:608:5)\n' +
+    '    at process.processImmediate (node:internal/timers:478:21)'
+}
+      ✔ should handle empty file contents
+      ✔ should handle Buffer content
+      ✔ should throw on invalid selector
+
+
+  18 passing (10ms)
+