funkophile 0.2.4 → 0.2.5

package/index.ts

@@ -4,8 +4,10 @@ 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';
@@ -13,6 +15,7 @@ export default (funkophileConfig: {
 	options: {
 		inFolder: string;
 		outFolder: string;
+		port?: number;
 	},
 	encodings: Record<string, string[]>,
 	inputs: Record<string, string>,
@@ -170,76 +173,218 @@ export default (funkophileConfig: {
     Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
       return {
         ...mm,
-        [inputKey]: createSelector([(x) => x], (root) => root[inputKey]),
+        [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}/`);
+    });
+  }
+
   // Wait for all the file watchers to check in
   Promise.all(
     Object.keys(funkophileConfig.inputs).map((inputRuleKey) => {
-      const p = path.resolve(
-        `./${funkophileConfig.options.inFolder}/${
-          funkophileConfig.inputs[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") {
-          glob(p, {})
+          // 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,
-                  file,
+                  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);
+                });
             })
-            .then(() => {
-              fulfill();
-            });
-        } else if (funkophileConfig.mode === "watch") {
-          chokidar
-            .watch(p, {})
-            .on("error", (error) => {
-              logger.watchError(p);
-            })
-            .on("ready", () => {
-              logger.watchReady(p);
-              fulfill();
-            })
-            .on("add", (p) => {
-              logger.watchAdd(p);
-              dispatchUpsert(
-                store,
-                inputRuleKey,
-                p,
-                funkophileConfig.encodings
-              );
-            })
-            .on("change", (p) => {
-              logger.watchChange(p);
-              dispatchUpsert(
-                store,
-                inputRuleKey,
-                p,
-                funkophileConfig.encodings
-              );
-            })
-            .on("unlink", (p) => {
-              logger.watchUnlink(p);
-              store.dispatch({
-                type: REMOVE,
-                payload: {
-                  key: inputRuleKey,
-                  file: p,
-                },
-              });
-            })
-            .on("unlinkDir", (p) => {
-              logger.watchUnlink(p);
+            .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);
@@ -253,15 +398,57 @@ export default (funkophileConfig: {
       });
     })
   ).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
     store.subscribe(() => {
       const s = store.getState();
+      
+      // 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));
+        return;
+      }
 
       logger.stateChange();
-      const outputs = finalSelector(s);
+      console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Processing state changes...');
+      
+      let outputs;
+      try {
+        outputs = finalSelector(s);
+        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);
+        // Don't exit the process in watch mode, just log the error and continue
+        if (funkophileConfig.mode === 'build') {
+          process.exit(1);
+        } else {
+          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 => {
+            delete previousState[key];
+          });
+          return;
+        }
+      }
 
       if (outputPromise.isPending()) {
-        console.log("cancelling previous write!");
+        console.log("\u001b[33m\u001b[1m[Funkophile]\u001b[0m Cancelling previous write operation!");
         outputPromise.cancel();
       }
 
@@ -273,6 +460,7 @@ 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}`);
 
               try {
                 fse.unlinkSync("./" + file);
@@ -280,14 +468,12 @@ export default (funkophileConfig: {
                   "./" + file.substring(0, file.lastIndexOf("/"))
                 );
               } catch (ex) {
-                // console.error('inner', ex.message);
-                // throw 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);
               } finally {
-                // console.log('finally');
-                return;
+                delete previousState[key];
+                fulfill();
               }
-              // delete previousState[key]
-              // fulfill()
             } else {
               if (outputs[key] !== previousState[key]) {
                 previousState[key] = outputs[key];
@@ -296,77 +482,146 @@ export default (funkophileConfig: {
                   "./" + funkophileConfig.options.outFolder + "/" + key;
                 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) => {
-                    fse.outputFile(relativeFilePath, res, fulfill);
-                    logger.writingString(relativeFilePath);
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill(); // Still fulfill to continue processing other files
+                    } else {
+                      fse.outputFile(relativeFilePath, res, (err) => {
+                        if (err) {
+                          logger.writingError(relativeFilePath, err.message);
+                          fulfill(); // Still fulfill to continue processing other files
+                        } else {
+                          logger.writingString(relativeFilePath);
+                          fulfill();
+                        }
+                      });
+                    }
                   });
                 } else if (typeof contents === "string") {
-                  fse.outputFile(relativeFilePath, contents, fulfill);
-                  logger.writingString(relativeFilePath);
+                  fse.outputFile(relativeFilePath, contents, (err) => {
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill();
+                    } else {
+                      logger.writingString(relativeFilePath);
+                      fulfill();
+                    }
+                  });
                 } else if (Buffer.isBuffer(contents)) {
-                  fse.outputFile(relativeFilePath, contents, fulfill);
-                  logger.writingString(relativeFilePath);
+                  fse.outputFile(relativeFilePath, contents, (err) => {
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill();
+                    } else {
+                      logger.writingString(relativeFilePath);
+                      fulfill();
+                    }
+                  });
                 } else if (Array.isArray(contents)) {
                   fse.outputFile(
                     relativeFilePath,
                     JSON.stringify(contents),
-                    fulfill
+                    (err) => {
+                      if (err) {
+                        logger.writingError(relativeFilePath, err.message);
+                        fulfill();
+                      } else {
+                        logger.writingString(relativeFilePath);
+                        fulfill();
+                      }
+                    }
                   );
-                  logger.writingString(relativeFilePath);
                 } else if (typeof contents.then === "function") {
                   logger.writingPromise(relativeFilePath);
                   Promise.resolve(contents).then(
                     function (value) {
                       if (value instanceof Error) {
                         logger.writingError(relativeFilePath, value.message);
+                        fulfill();
                       } else {
-                        fse.outputFile(relativeFilePath, value, fulfill);
-                        logger.writingString(relativeFilePath);
+                        fse.outputFile(relativeFilePath, value, (err) => {
+                          if (err) {
+                            logger.writingError(relativeFilePath, err.message);
+                            fulfill();
+                          } else {
+                            logger.writingString(relativeFilePath);
+                            fulfill();
+                          }
+                        });
                       }
                     },
-                    function (value) {
-                      // not called
+                    function (error) {
+                      logger.writingError(relativeFilePath, error.message);
+                      fulfill();
                     }
                   );
                 } else {
                   console.log(
-                    `I don't recognize what this is but I will try to write it to a file: ` +
-                      relativeFilePath,
-                    typeof contents,
-                    contents
+                    `\u001b[33m\u001b[1m[Funkophile]\u001b[0m Unrecognized content type for ${relativeFilePath}, attempting to write:`,
+                    typeof contents
                   );
-                  fse.outputFile(relativeFilePath, contents, fulfill);
-                  logger.writingString(relativeFilePath);
+                  fse.outputFile(relativeFilePath, contents, (err) => {
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill();
+                    } else {
+                      logger.writingString(relativeFilePath);
+                      fulfill();
+                    }
+                  });
                 }
               } else {
+                // console.log(`\u001b[90m\u001b[1m[Funkophile]\u001b[0m Skipping unchanged file: ${key}`);
                 fulfill();
               }
             }
           });
         })
       ).then(() => {
+        // 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 {
-          console.error(
-            `The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
+          throw (
+            `\u001b[31m\u001b[1m[Funkophile]\u001b[0m The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
           );
-          process.exit(-1);
+
         }
-      });
+      })
+      //   .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...');
+  });
+
+  // Handle process exit to close the server
+  process.on('SIGINT', () => {
+    if (server) {
+      server.close();
+    }
+    process.exit(0);
   });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "funkophile",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "repository": "git@github.com:adamwong246/funkophile.git",
   "author": "adam wong <adamwong246@gmail.com>",
   "license": "MIT",
@@ -12,7 +12,8 @@
   "main": "./dist/esm.index.js",
   "types": "./dist/esm/index.d.ts",
   "scripts": {
-    "transpile": "tsc --project tsconfig.json "
+    "transpile": "tsc --project tsconfig.json",
+    "dev": "tsc --watch --project tsconfig.json"
   },
   "dependencies": {
     "@tsconfig/node-lts-strictest-esm": "^18.12.1",
@@ -28,6 +29,9 @@
     "tsc": "^2.0.4",
     "typescript": "^5.8.2"
   },
+  "devDependencies": {
+    "chokidar-cli": "^3.0.0"
+  },
   "exports": {
     ".": {
       "types": "./dist/esm/index.d.ts",

package/tsconfig.json

@@ -8,7 +8,8 @@
     "declaration": true,
     "strict": true,
     "rootDir": ".",
-    "noImplicitAny": false
+    "noImplicitAny": false,
+    "useUnknownInCatchVariables": false
   },
   "include": ["*.ts"],
   "exclude": ["node_modules"]