funkophile 0.2.5 → 1.0.0

package/dist/esm/index.js

@@ -1,531 +1,657 @@
-import chokidar from "chokidar";
-import { createSelector } from "reselect";
-import { createStore } from "redux";
+// index.ts
+import Promise2 from "bluebird";
+import fse2 from "fs-extra";
+
+// utils.ts
 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 { createStore } from "redux";
+import { createSelector } from "reselect";
 import url from "url";
-export default (funkophileConfig) => {
-    Promise.config({
-        cancellation: true,
+import { glob } from "glob";
+import chokidar from "chokidar";
+var INITIALIZE = "INITIALIZE";
+var UPSERT = "UPSERT";
+var REMOVE = "REMOVE";
+var previousState = {};
+var logger = {
+  watchError: (p) => console.log("\x1B[7m ! \x1B[0m" + p),
+  watchReady: (p) => console.log("\x1B[7m\x1B[36m  <  \x1B[0m" + p),
+  watchAdd: (p) => console.log("\x1B[7m\x1B[34m  +  \x1B[0m./" + p),
+  watchChange: (p) => console.log("\x1B[7m\x1B[35m  *  \x1B[0m" + p),
+  watchUnlink: (p) => console.log("\x1B[7m\x1B[31m  -  \x1B[0m./" + p),
+  stateChange: () => console.log("\x1B[7m\x1B[31m --- Redux state changed --- \x1B[0m"),
+  cleaningEmptyfolder: (p) => console.log("\x1B[31m\x1B[7m XXX! \x1B[0m" + p),
+  readingFile: (p) => console.log("\x1B[31m <-- \x1B[0m" + p),
+  removedFile: (p) => console.log("\x1B[31m\x1B[7m ??? \x1B[0m./" + p),
+  writingString: (p) => console.log("\x1B[32m --> \x1B[0m" + p),
+  writingFunction: (p) => console.log("\x1B[33m ... \x1B[0m" + p),
+  writingPromise: (p) => console.log("\x1B[33m ... \x1B[0m" + p),
+  writingError: (p, message) => console.log("\x1B[31m !!! \x1B[0m" + p + " " + message),
+  waiting: () => console.log(
+    "\x1B[7m Funkophile is done for now but waiting on changes...\x1B[0m "
+  ),
+  done: () => console.log("\x1B[7m Funkophile is done!\x1B[0m ")
+};
+function cleanEmptyFoldersRecursively(folder) {
+  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);
     });
-    const INITIALIZE = "INITIALIZE";
-    const UPSERT = "UPSERT";
-    const REMOVE = "REMOVE";
-    const previousState = {};
-    let outputPromise = Promise.resolve();
-    const logger = {
-        watchError: (p) => console.log("\u001b[7m ! \u001b[0m" + p),
-        watchReady: (p) => console.log("\u001b[7m\u001b[36m  <  \u001b[0m" + p),
-        watchAdd: (p) => console.log("\u001b[7m\u001b[34m  +  \u001b[0m./" + p),
-        watchChange: (p) => console.log("\u001b[7m\u001b[35m  *  \u001b[0m" + p),
-        watchUnlink: (p) => console.log("\u001b[7m\u001b[31m  -  \u001b[0m./" + p),
-        stateChange: () => console.log("\u001b[7m\u001b[31m --- Redux state changed --- \u001b[0m"),
-        cleaningEmptyfolder: (p) => console.log("\u001b[31m\u001b[7m XXX! \u001b[0m" + p),
-        readingFile: (p) => console.log("\u001b[31m <-- \u001b[0m" + p),
-        removedFile: (p) => console.log("\u001b[31m\u001b[7m ??? \u001b[0m./" + p),
-        writingString: (p) => console.log("\u001b[32m --> \u001b[0m" + p),
-        writingFunction: (p) => console.log("\u001b[33m ... \u001b[0m" + p),
-        writingPromise: (p) => console.log("\u001b[33m ... \u001b[0m" + p),
-        writingError: (p, message) => 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) {
-        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, key, file, encodings) => {
-        const fileType = path.basename(file).split(".")[1];
-        let encoding = Object.keys(encodings).find((e) => {
-            return encodings[e].includes(fileType);
-        });
-        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, obj) {
-        const { [key]: omitted, ...rest } = obj;
-        return rest;
+    files = fs.readdirSync(folder);
+  }
+  if (files.length == 0) {
+    logger.cleaningEmptyfolder(folder);
+    fs.rmdirSync(folder);
+    return;
+  }
+}
+var dispatchUpsert = (store, key, file, encodings) => {
+  const fileType = path.basename(file).split(".")[1];
+  let encoding = Object.keys(encodings).find((e) => {
+    return encodings[e].includes(fileType);
+  });
+  logger.readingFile(file);
+  store.dispatch({
+    type: UPSERT,
+    payload: {
+      key,
+      // key: path.relative(process.cwd(), key),
+      src: file,
+      contents: fse.readFileSync(file, encoding)
     }
-    const store = createStore((state = {
-        initialLoad: true,
-        ...funkophileConfig.initialState,
-        timestamp: Date.now(),
+  });
+};
+function omit(key, obj) {
+  const { [key]: omitted, ...rest } = obj;
+  return rest;
+}
+function newStore(funkophileConfig) {
+  const initialInputState = Object.keys(funkophileConfig.inputs).reduce(
+    (state, inputKey) => {
+      state[inputKey] = {};
+      return state;
+    },
+    {}
+  );
+  return createStore(
+    (state = {
+      initialLoad: true,
+      ...initialInputState,
+      ...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
+      if (state === void 0) {
+        throw new Error("Redux state is undefined. This should never happen.");
+      }
+      console.log(
+        `\x1B[35m\x1B[1m[Funkophile]\x1B[0m Redux received action: ${action.type}`
+      );
+      if (!action.type.includes("@@redux")) {
+        if (action.type === INITIALIZE) {
+          console.log(
+            `\x1B[35m\x1B[1m[Funkophile]\x1B[0m INITIALIZE action - setting initialLoad to false`
+          );
+          return {
+            ...state,
+            initialLoad: false,
+            timestamp: Date.now()
+          };
+        } else if (action.type === UPSERT) {
+          console.log(
+            `\x1B[35m\x1B[1m[Funkophile]\x1B[0m UPSERT action for key: ${action["payload"].key}, file: ${action["payload"].src}`
+          );
+          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) {
+          console.log(
+            `\x1B[35m\x1B[1m[Funkophile]\x1B[0m REMOVE action for key: ${action["payload"].key}, file: ${action["payload"].file}`
+          );
+          const currentKeyState = state[action["payload"].key] || {};
+          return {
+            ...state,
+            [action["payload"].key]: omit(
+              action["payload"].file,
+              currentKeyState
+            ),
+            timestamp: Date.now()
+          };
+        } else {
+          console.error(
+            "Redux was asked to handle an unknown action type: " + action.type
+          );
+          process.exit(-1);
         }
-    });
-    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 = 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 = {
-                                '.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);
-                        }
-                    });
-                }
+      }
+      return state;
+    }
+  );
+}
+function makeFinalSelector(funkophileConfig) {
+  return funkophileConfig.outputs(
+    Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
+      return {
+        ...mm,
+        [inputKey]: createSelector([(x) => x], (root) => {
+          const result = root[inputKey];
+          if (result === void 0) {
+            console.warn(
+              `\x1B[33m\x1B[1m[Funkophile]\x1B[0m Input key "${inputKey}" is undefined in state, which shouldn't happen. Using empty object.`
+            );
+            return {};
+          }
+          return result;
+        })
+      };
+    }, {})
+  );
+}
+function startServing(funkophileConfig) {
+  const port = funkophileConfig.options.port || 8080;
+  const 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;
+    if (pathname && pathname.endsWith("/")) {
+      pathname += "index.html";
+    }
+    const filePath = pathname ? pathname.substring(1) : "index.html";
+    const fullPath = path.join(
+      process.cwd(),
+      funkophileConfig.options.outFolder,
+      filePath
+    );
+    fs.access(fullPath, fs.constants.F_OK, (err) => {
+      if (err) {
+        const htmlPath = fullPath + ".html";
+        fs.access(htmlPath, fs.constants.F_OK, (htmlErr) => {
+          if (htmlErr) {
+            res.statusCode = 404;
+            res.end("File not found");
+          } else {
+            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);
+              }
             });
+          }
         });
-        server.listen(port, () => {
-            console.log(`\u001b[36m\u001b[1m[Funkophile]\u001b[0m Server running at http://localhost:${port}/`);
+      } else {
+        fs.readFile(fullPath, (readErr, data) => {
+          if (readErr) {
+            res.statusCode = 500;
+            res.end("Internal Server Error");
+          } else {
+            const ext = path.extname(fullPath).toLowerCase();
+            const contentTypes = {
+              ".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(
+      `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Server running at http://localhost:${port}/`
+    );
+  });
+  process.on("SIGINT", () => {
+    if (server) {
+      server.close();
     }
-    // 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) => {
-                    // 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) => {
-                    // 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);
-            }
+  });
+}
+function logInputKeys(funkophileConfig, currentState) {
+  Object.keys(funkophileConfig.inputs).forEach((inputKey) => {
+    if (currentState[inputKey]) {
+      console.log(
+        `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Input key "${inputKey}" found in state with ${Object.keys(currentState[inputKey]).length} files`
+      );
+      if (Object.keys(currentState[inputKey]).length > 0) {
+        console.log(
+          `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Files for "${inputKey}":`,
+          Object.keys(currentState[inputKey])
+        );
+      }
+    } else {
+      console.warn(
+        `\x1B[33m\x1B[1m[Funkophile]\x1B[0m Input key "${inputKey}" NOT found in state`
+      );
+    }
+  });
+}
+function logDone(funkophileConfig, currentState) {
+  if (funkophileConfig.mode === "build") {
+    console.log(
+      "\x1B[32m\x1B[1m[Funkophile]\x1B[0m Build completed successfully!"
+    );
+    logger.done();
+  } else if (funkophileConfig.mode === "watch") {
+    console.log(
+      "\x1B[36m\x1B[1m[Funkophile]\x1B[0m Watching for file changes..."
+    );
+    const port = funkophileConfig.options.port || 8080;
+    console.log(
+      `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Serving at: http://localhost:${port}/`
+    );
+    logger.waiting();
+  } else {
+    throw `\x1B[31m\x1B[1m[Funkophile]\x1B[0m The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`;
+  }
+}
+function makePromissesArray(funkophileConfig, store) {
+  return Object.keys(funkophileConfig.inputs).map((inputRuleKey) => {
+    const pattern = funkophileConfig.inputs[inputRuleKey] || "";
+    const globPattern = path.posix.join(
+      funkophileConfig.options.inFolder,
+      pattern
+    );
+    return new Promise((fulfill, reject) => {
+      if (funkophileConfig.mode === "build") {
+        glob(globPattern, { cwd: process.cwd() }).then((files) => {
+          if (files.length === 0) {
+            console.warn(
+              `No files found for input key "${inputRuleKey}" with pattern "${globPattern}"`
+            );
+          } else {
+            files.forEach((file) => {
+              const absoluteFilePath = path.resolve(process.cwd(), file);
+              dispatchUpsert(
+                store,
+                inputRuleKey,
+                absoluteFilePath,
+                funkophileConfig.encodings
+              );
+            });
+          }
+        }).then(() => {
+          fulfill();
+        }).catch((error) => {
+          reject(error);
         });
-    })).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`);
+      } else if (funkophileConfig.mode === "watch") {
+        console.log(
+          `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Setting up watcher for pattern: ${globPattern}`
+        );
+        console.log(
+          `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Current working directory: ${process.cwd()}`
+        );
+        glob(globPattern, { cwd: process.cwd() }).then((files) => {
+          console.log(
+            `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Found ${files.length} initial files for ${inputRuleKey}`
+          );
+          files.forEach((file) => {
+            const absoluteFilePath = path.resolve(process.cwd(), file);
+            console.log(
+              `\x1B[32m\x1B[1m[Funkophile]\x1B[0m Adding initial file: ${file}`
+            );
+            dispatchUpsert(
+              store,
+              inputRuleKey,
+              absoluteFilePath,
+              funkophileConfig.encodings
+            );
+          });
+          const watcher = chokidar.watch(globPattern, {
+            cwd: process.cwd(),
+            ignoreInitial: true,
+            // We've already processed initial files
+            persistent: true,
+            usePolling: false,
+            interval: 100,
+            binaryInterval: 300,
+            alwaysStat: false,
+            depth: 99,
+            awaitWriteFinish: {
+              stabilityThreshold: 50,
+              pollInterval: 10
             }
+          }).on("error", (error) => {
+            console.error(
+              `\x1B[31m\x1B[1m[Funkophile]\x1B[0m Watcher error for pattern ${globPattern}:`,
+              error
+            );
+            logger.watchError(globPattern);
+          }).on("add", (filePath) => {
+            console.log(
+              `\x1B[32m\x1B[1m[Funkophile]\x1B[0m File added: ${filePath}`
+            );
+            logger.watchAdd(filePath);
+            const absoluteFilePath = path.resolve(process.cwd(), filePath);
+            console.log(
+              `\x1B[32m\x1B[1m[Funkophile]\x1B[0m Dispatching UPSERT for key: ${inputRuleKey}, file: ${absoluteFilePath}`
+            );
+            dispatchUpsert(
+              store,
+              inputRuleKey,
+              absoluteFilePath,
+              funkophileConfig.encodings
+            );
+          }).on("change", (filePath) => {
+            console.log(
+              `\x1B[33m\x1B[1m[Funkophile]\x1B[0m File changed: ${filePath}`
+            );
+            logger.watchChange(filePath);
+            const absoluteFilePath = path.resolve(process.cwd(), filePath);
+            console.log(
+              `\x1B[33m\x1B[1m[Funkophile]\x1B[0m Dispatching UPSERT for key: ${inputRuleKey}, file: ${absoluteFilePath}`
+            );
+            dispatchUpsert(
+              store,
+              inputRuleKey,
+              absoluteFilePath,
+              funkophileConfig.encodings
+            );
+          }).on("unlink", (filePath) => {
+            console.log(
+              `\x1B[31m\x1B[1m[Funkophile]\x1B[0m File removed: ${filePath}`
+            );
+            logger.watchUnlink(filePath);
+            const absoluteFilePath = path.resolve(process.cwd(), filePath);
+            console.log(
+              `\x1B[31m\x1B[1m[Funkophile]\x1B[0m Dispatching REMOVE for key: ${inputRuleKey}, file: ${absoluteFilePath}`
+            );
+            store.dispatch({
+              type: REMOVE,
+              payload: {
+                key: inputRuleKey,
+                file: absoluteFilePath
+              }
+            });
+          }).on("unlinkDir", (filePath) => {
+            console.log(
+              `\x1B[31m\x1B[1m[Funkophile]\x1B[0m Directory removed: ${filePath}`
+            );
+            logger.watchUnlink(filePath);
+          }).on("raw", (event, path2, details) => {
+            console.log(
+              `\x1B[90m\x1B[1m[Funkophile]\x1B[0m Raw event: ${event} for path: ${path2}`
+            );
+          });
+          console.log(
+            `\x1B[32m\x1B[1m[Funkophile]\x1B[0m Watcher is ready for pattern: ${globPattern}`
+          );
+          logger.watchReady(globPattern);
+          fulfill();
+        }).catch((error) => {
+          console.error(
+            `\x1B[31m\x1B[1m[Funkophile]\x1B[0m Error processing initial files for pattern ${globPattern}:`,
+            error
+          );
+          reject(error);
         });
-        // 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();
-            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("\u001b[33m\u001b[1m[Funkophile]\u001b[0m Cancelling previous write operation!");
-                outputPromise.cancel();
-            }
-            outputPromise = Promise.all(Array.from(new Set(Object.keys(previousState).concat(Object.keys(outputs)))).map((key) => {
-                return new Promise((fulfill, reject) => {
-                    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);
-                            cleanEmptyFoldersRecursively("./" + file.substring(0, file.lastIndexOf("/")));
-                        }
-                        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);
-                        }
-                        finally {
-                            delete previousState[key];
-                            fulfill();
+      } else {
+        console.error(
+          `mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
+        );
+        process.exit(-1);
+      }
+    });
+  });
+}
+
+// index.ts
+Promise2.config({
+  cancellation: true
+});
+var index_default = (funkophileConfig) => {
+  let outputPromise = Promise2.resolve();
+  const store = newStore(funkophileConfig);
+  const finalSelector = makeFinalSelector(funkophileConfig);
+  if (funkophileConfig.mode === "watch") {
+    startServing(funkophileConfig);
+  }
+  Promise2.all(
+    makePromissesArray(funkophileConfig, store)
+  ).then(function() {
+    console.log(
+      "\x1B[32m\x1B[1m[Funkophile]\x1B[0m All input watchers are ready. Setting up store subscription..."
+    );
+    store.subscribe(() => {
+      const s = store.getState();
+      console.log(
+        `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Store updated. initialLoad: ${s.initialLoad}, timestamp: ${s.timestamp}`
+      );
+      if (s.initialLoad) {
+        console.log(
+          "\x1B[36m\x1B[1m[Funkophile]\x1B[0m Initial load in progress, skipping processing..."
+        );
+        console.log(
+          "\x1B[36m\x1B[1m[Funkophile]\x1B[0m State keys during initial load:",
+          Object.keys(s)
+        );
+        return;
+      }
+      logger.stateChange();
+      console.log(
+        "\x1B[36m\x1B[1m[Funkophile]\x1B[0m Processing state changes..."
+      );
+      console.log(
+        "\x1B[36m\x1B[1m[Funkophile]\x1B[0m Current state keys:",
+        Object.keys(s)
+      );
+      let outputs;
+      try {
+        outputs = finalSelector(s);
+        console.log(
+          `\x1B[36m\x1B[1m[Funkophile]\x1B[0m Generated ${Object.keys(outputs).length} outputs`
+        );
+      } catch (error) {
+        console.error(
+          "\x1B[31m\x1B[1m[Funkophile]\x1B[0m FATAL: Error in output selector chain ? :"
+        );
+        console.error("  Error:", error.message);
+        console.error("  Stack:", error.stack);
+        if (funkophileConfig.mode === "build") {
+          process.exit(1);
+        } else {
+          console.log(
+            "\x1B[33m\x1B[1m[Funkophile]\x1B[0m Continuing to watch for changes despite error..."
+          );
+          Object.keys(previousState).forEach((key) => {
+            delete previousState[key];
+          });
+          return;
+        }
+      }
+      if (outputPromise.isPending()) {
+        console.log(
+          "\x1B[33m\x1B[1m[Funkophile]\x1B[0m Cancelling previous write operation!"
+        );
+        outputPromise.cancel();
+      }
+      outputPromise = Promise2.all(
+        Array.from(
+          new Set(Object.keys(previousState).concat(Object.keys(outputs)))
+        ).map((key) => {
+          return new Promise2((fulfill, reject) => {
+            if (!outputs[key]) {
+              const file = funkophileConfig.options.outFolder + "/" + key;
+              logger.removedFile(file);
+              console.log(
+                `\x1B[31m\x1B[1m[Funkophile]\x1B[0m Removing file: ${file}`
+              );
+              try {
+                fse2.unlinkSync("./" + file);
+                cleanEmptyFoldersRecursively(
+                  "./" + file.substring(0, file.lastIndexOf("/"))
+                );
+              } catch (ex) {
+                console.error(
+                  `\x1B[31m\x1B[1m[Funkophile]\x1B[0m Error removing file ${file}:`,
+                  ex.message
+                );
+              } finally {
+                delete previousState[key];
+                fulfill();
+              }
+            } else {
+              if (outputs[key] !== previousState[key]) {
+                previousState[key] = outputs[key];
+                const relativeFilePath = "./" + funkophileConfig.options.outFolder + "/" + key;
+                const contents = outputs[key];
+                if (typeof contents === "function") {
+                  logger.writingFunction(relativeFilePath);
+                  contents((err, res) => {
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill();
+                    } else {
+                      fse2.outputFile(relativeFilePath, res, (err2) => {
+                        if (err2) {
+                          logger.writingError(relativeFilePath, err2.message);
+                          fulfill();
+                        } else {
+                          logger.writingString(relativeFilePath);
+                          fulfill();
                         }
+                      });
                     }
-                    else {
-                        if (outputs[key] !== previousState[key]) {
-                            previousState[key] = outputs[key];
-                            const relativeFilePath = "./" + 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) => {
-                                    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, (err) => {
-                                    if (err) {
-                                        logger.writingError(relativeFilePath, err.message);
-                                        fulfill();
-                                    }
-                                    else {
-                                        logger.writingString(relativeFilePath);
-                                        fulfill();
-                                    }
-                                });
-                            }
-                            else if (Buffer.isBuffer(contents)) {
-                                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), (err) => {
-                                    if (err) {
-                                        logger.writingError(relativeFilePath, err.message);
-                                        fulfill();
-                                    }
-                                    else {
-                                        logger.writingString(relativeFilePath);
-                                        fulfill();
-                                    }
-                                });
-                            }
-                            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, (err) => {
-                                            if (err) {
-                                                logger.writingError(relativeFilePath, err.message);
-                                                fulfill();
-                                            }
-                                            else {
-                                                logger.writingString(relativeFilePath);
-                                                fulfill();
-                                            }
-                                        });
-                                    }
-                                }, function (error) {
-                                    logger.writingError(relativeFilePath, error.message);
-                                    fulfill();
-                                });
-                            }
-                            else {
-                                console.log(`\u001b[33m\u001b[1m[Funkophile]\u001b[0m Unrecognized content type for ${relativeFilePath}, attempting to write:`, typeof contents);
-                                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}`);
+                  });
+                } else if (typeof contents === "string") {
+                  fse2.outputFile(relativeFilePath, contents, (err) => {
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill();
+                    } else {
+                      logger.writingString(relativeFilePath);
+                      fulfill();
+                    }
+                  });
+                } else if (Buffer.isBuffer(contents)) {
+                  fse2.outputFile(relativeFilePath, contents, (err) => {
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill();
+                    } else {
+                      logger.writingString(relativeFilePath);
+                      fulfill();
+                    }
+                  });
+                } else if (Array.isArray(contents)) {
+                  fse2.outputFile(
+                    relativeFilePath,
+                    JSON.stringify(contents),
+                    (err) => {
+                      if (err) {
+                        logger.writingError(relativeFilePath, err.message);
+                        fulfill();
+                      } else {
+                        logger.writingString(relativeFilePath);
+                        fulfill();
+                      }
+                    }
+                  );
+                } else if (typeof contents.then === "function") {
+                  logger.writingPromise(relativeFilePath);
+                  Promise2.resolve(contents).then(
+                    function(value) {
+                      if (value instanceof Error) {
+                        logger.writingError(relativeFilePath, value.message);
+                        fulfill();
+                      } else {
+                        fse2.outputFile(relativeFilePath, value, (err) => {
+                          if (err) {
+                            logger.writingError(relativeFilePath, err.message);
                             fulfill();
-                        }
+                          } else {
+                            logger.writingString(relativeFilePath);
+                            fulfill();
+                          }
+                        });
+                      }
+                    },
+                    function(error) {
+                      logger.writingError(relativeFilePath, error.message);
+                      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 {
-                    throw (`\u001b[31m\u001b[1m[Funkophile]\u001b[0m The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`);
+                  );
+                } else {
+                  console.log(
+                    `\x1B[33m\x1B[1m[Funkophile]\x1B[0m Unrecognized content type for ${relativeFilePath}, attempting to write:`,
+                    typeof contents
+                  );
+                  fse2.outputFile(relativeFilePath, contents, (err) => {
+                    if (err) {
+                      logger.writingError(relativeFilePath, err.message);
+                      fulfill();
+                    } else {
+                      logger.writingString(relativeFilePath);
+                      fulfill();
+                    }
+                  });
                 }
-            });
-            //   .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);
+              } else {
+                fulfill();
+              }
+            }
+          });
+        })
+      ).then(() => {
+        cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
+        logDone(funkophileConfig, currentState);
+      });
     });
+    console.log(
+      "\x1B[32m\x1B[1m[Funkophile]\x1B[0m Dispatching INITIALIZE action to enable processing..."
+    );
+    const currentState = store.getState();
+    console.log(
+      "\x1B[36m\x1B[1m[Funkophile]\x1B[0m Current state keys:",
+      Object.keys(currentState)
+    );
+    logInputKeys(funkophileConfig, currentState);
+    setTimeout(() => {
+      store.dispatch({
+        type: INITIALIZE,
+        payload: true
+      });
+      console.log(
+        "\x1B[32m\x1B[1m[Funkophile]\x1B[0m Store initialized. Ready to process changes!"
+      );
+    }, 100);
+  });
+};
+export {
+  index_default as default
 };
+//# sourceMappingURL=index.js.map