funkophile 0.2.4 → 1.0.0

package/index.ts

@@ -1,267 +1,103 @@
-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 path from "path";
 import Promise from "bluebird";
+import fse from "fs-extra";
 
-export default (funkophileConfig: {
-	mode: 'build' | 'watch';
-	initialState: any;
-	options: {
-		inFolder: string;
-		outFolder: string;
-	},
-	encodings: Record<string, string[]>,
-	inputs: Record<string, string>,
-	outputs: (x: any) => any;
-}) => {
+import { Action, Store } from "redux";
+import {
+  IConfig,
+  INITIALIZE,
+  cleanEmptyFoldersRecursively,
+  logDone,
+  logInputKeys,
+  logger,
+  makeFinalSelector,
+  makePromissesArray,
+  newStore,
+  previousState,
+  startServing,
+} from "./utils";
 
-  Promise.config({
-    cancellation: true,
-  });
+Promise.config({
+  cancellation: true,
+});
 
-  const INITIALIZE = "INITIALIZE";
-  const UPSERT = "UPSERT";
-  const REMOVE = "REMOVE";
-
-  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;
-    }
+  if (funkophileConfig.mode === "watch") {
+    startServing(funkophileConfig);
   }
 
-  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),
-      },
-    });
-  };
+  // Wait for all the file watchers to check in
+  Promise.all(
+    makePromissesArray(funkophileConfig, store)
+  ).then(function () {
+    console.log(
+      "\u001b[32m\u001b[1m[Funkophile]\u001b[0m All input watchers are ready. Setting up store subscription..."
+    );
 
-  function omit(key: string, obj: any) {
-    const { [key]: omitted, ...rest } = obj;
-    return rest;
-  }
+    // 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}`
+      );
 
-  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
+      // 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;
       }
-    }
-  );
 
-  const finalSelector = funkophileConfig.outputs(
-    Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
-      return {
-        ...mm,
-        [inputKey]: createSelector([(x) => x], (root) => root[inputKey]),
-      };
-    }, {})
-  );
-
-  // 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] || ""
-        }`
+      logger.stateChange();
+      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)
       );
 
-      return new Promise((fulfill, reject) => {
+      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") {
-          glob(p, {})
-            .then((files: string[]) => {
-              files.forEach((file) => {
-                dispatchUpsert(
-                  store,
-                  inputRuleKey,
-                  file,
-                  funkophileConfig.encodings
-                );
-              });
-            })
-            .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);
-            });
-          // .on('raw', (event, p, details) => { // internal
-          //   log('Raw event info:', event, p, details);
-          // })
+          process.exit(1);
         } else {
-          console.error(
-            `mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
+          console.log(
+            "\u001b[33m\u001b[1m[Funkophile]\u001b[0m Continuing to watch for changes despite error..."
           );
-          process.exit(-1);
+          // Reset previousState to empty to ensure we try processing again on next change
+          Object.keys(previousState).forEach((key) => {
+            delete previousState[key];
+          });
+          return;
         }
-      });
-    })
-  ).then(function () {
-    // listen for changes to the store
-    store.subscribe(() => {
-      const s = store.getState();
-
-      logger.stateChange();
-      const outputs = finalSelector(s);
+      }
 
       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 +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}`
+              );
 
               try {
                 fse.unlinkSync("./" + file);
@@ -280,14 +119,15 @@ 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 +136,140 @@ 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") {
-          logger.done();
-        } else if (funkophileConfig.mode === "watch") {
-          logger.waiting();
-        } else {
-          console.error(
-            `The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
-          );
-          process.exit(-1);
-        }
+        logDone(funkophileConfig, currentState) 
       });
+      //   .catch((error) => {
+      //   // console.error('\u001b[31m\u001b[1m[Funkophile]\u001b[0m Error during file operations:', error);
+      // });
     });
 
-    // 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 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);
+
+    // 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)
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "funkophile",
-  "version": "0.2.4",
+  "version": "1.0.0",
   "repository": "git@github.com:adamwong246/funkophile.git",
   "author": "adam wong <adamwong246@gmail.com>",
   "license": "MIT",
@@ -9,33 +9,56 @@
     "static site generator"
   ],
   "type": "module",
-  "main": "./dist/esm.index.js",
+  "test": "mocha",
+  "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
+  "mocha": {
+    "node-option": [
+      "import=tsx"
+    ]
+  },
   "scripts": {
-    "transpile": "tsc --project tsconfig.json "
+    "build": "tsx build.ts",
+    "dev": "tsx --watch dev.ts",
+    "test": "mocha index.test.ts",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@tsconfig/node-lts-strictest-esm": "^18.12.1",
     "@types/bluebird": "^3.5.42",
+    "@types/chai": "^5.2.2",
     "@types/chokidar": "^2.1.7",
     "@types/fs-extra": "^11.0.4",
+    "@types/mocha": "^10.0.10",
     "@types/redux": "^3.6.0",
     "@types/reselect": "^2.2.0",
     "bluebird": "3.7.2",
+    "chai": "^5.2.1",
     "chokidar": "^4.0.3",
+    "esbuild": "^0.25.0",
     "fs-extra": "^11.3.0",
     "glob": "11.0.1",
+    "mocha": "^11.7.1",
+    "mocha-junit-reporter": "^2.2.0",
+    "ts-node": "^10.9.1",
     "tsc": "^2.0.4",
+    "tsx": "^4.20.6",
     "typescript": "^5.8.2"
   },
+  "devDependencies": {
+    "chokidar-cli": "^3.0.0"
+  },
   "exports": {
     ".": {
-      "types": "./dist/esm/index.d.ts",
-      "import": "./dist/esm/index.js",
+      "import": {
+        "default": "./dist/esm/index.js"
+      },
       "default": "./dist/esm/index.js"
     },
     "./funkophileHelpers": {
-      "import": "./dist/esm/funkophileHelpers.js"
+      "types": "./dist/esm/funkophileHelpers.d.ts",
+      "import": "./dist/esm/funkophileHelpers.js",
+      "default": "./dist/esm/funkophileHelpers.js"
     }
   }
 }