funkophile 0.2.5 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "funkophile",
-  "version": "0.2.5",
+  "version": "1.0.1",
   "repository": "git@github.com:adamwong246/funkophile.git",
   "author": "adam wong <adamwong246@gmail.com>",
   "license": "MIT",
@@ -9,24 +9,40 @@
     "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",
-    "dev": "tsc --watch --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": {
@@ -34,12 +50,15 @@
   },
   "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"
     }
   }
 }

package/test-utils.ts

@@ -0,0 +1,40 @@
+import { AppState, FileContents, FunkophileConfig } from './core';
+
+export const createMockState = (partial?: Partial<AppState>): AppState => ({
+  timestamp: Date.now(),
+  posts: {
+    'post1.md': '# Post 1',
+    'post2.md': '# Post 2',
+    'post33.md': 'hello world'
+  },
+  pages: {
+    'about.md': '# About'
+  },
+  ...partial
+});
+
+export const createMockConfig = (partial?: Partial<FunkophileConfig>): FunkophileConfig => ({
+  mode: 'build',
+  initialState: {
+    posts: {
+      'post1.md': '# Post 1',
+      'post2.md': '# Post 2'
+    },
+    pages: {
+      'about.md': '# About'
+    }
+  },
+  options: {
+    inFolder: 'src',
+    outFolder: 'dist'
+  },
+  encodings: {
+    utf8: ['md', 'txt']
+  },
+  inputs: {
+    posts: 'posts/**/*.md',
+    pages: 'pages/**/*.md'
+  },
+  outputs: () => ({}),
+  ...partial
+});

package/tsconfig.json

@@ -1,5 +1,8 @@
 {
   "compilerOptions": {
+
+    "allowJs": true,
+
     "module": "ESNext",
     "target": "ESNext",
     "moduleResolution": "node",
@@ -9,8 +12,17 @@
     "strict": true,
     "rootDir": ".",
     "noImplicitAny": false,
-    "useUnknownInCatchVariables": false
+    "useUnknownInCatchVariables": false,
+    "emitDeclarationOnly": true,
+    "skipLibCheck": true
   },
-  "include": ["*.ts"],
-  "exclude": ["node_modules"]
-}
+  "include": [
+    "index.ts",
+    "funkophileHelpers.ts",
+    "utils.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/utils.ts

@@ -0,0 +1,539 @@
+import fs from "fs";
+import fse from "fs-extra";
+import http from "http";
+import path from "path";
+import { Action, createStore, Store } from "redux";
+import { createSelector } from "reselect";
+import url from "url";
+import { glob } from "glob";
+import chokidar from "chokidar";
+
+export type IConfig = {
+  mode: "build" | "watch";
+  initialState: any;
+  options: {
+    inFolder: string;
+    outFolder: string;
+    port?: number;
+  };
+  encodings: Record<string, string[]>;
+  inputs: Record<string, string>;
+  outputs: (x: any) => any;
+};
+
+export const INITIALIZE = "INITIALIZE";
+export const UPSERT = "UPSERT";
+export const REMOVE = "REMOVE";
+
+export const previousState: any = {};
+
+export 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 "),
+};
+
+export 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;
+  }
+}
+
+export 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),
+    },
+  });
+};
+
+export function omit(key: string, obj: any) {
+  const { [key]: omitted, ...rest } = obj;
+  return rest;
+}
+
+export function newStore(funkophileConfig): Store<any, Action<string>, any> {
+  const initialInputState = Object.keys(funkophileConfig.inputs).reduce(
+    (state, inputKey) => {
+      state[inputKey] = {};
+      return state;
+    },
+    {} as Record<string, any>
+  );
+
+  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[35m\u001b[1m[Funkophile]\u001b[0m Redux received action: ${action.type}`
+      );
+      if (!action.type.includes("@@redux")) {
+        if (action.type === INITIALIZE) {
+          console.log(
+            `\u001b[35m\u001b[1m[Funkophile]\u001b[0m INITIALIZE action - setting initialLoad to false`
+          );
+          return {
+            ...state,
+            initialLoad: false,
+            timestamp: Date.now(),
+          };
+        } else if (action.type === UPSERT) {
+          console.log(
+            `\u001b[35m\u001b[1m[Funkophile]\u001b[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(
+            `\u001b[35m\u001b[1m[Funkophile]\u001b[0m REMOVE action for key: ${action["payload"].key}, file: ${action["payload"].file}`
+          );
+          // Ensure the key exists before trying to omit from it
+          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);
+        }
+        // return state
+      }
+      return state;
+    }
+  );
+}
+
+export function makeFinalSelector(funkophileConfig) {
+  return funkophileConfig.outputs(
+    Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
+      return {
+        ...mm,
+        [inputKey]: createSelector([(x) => x], (root) => {
+          // The input key should always be present now, even if it's an empty object
+          const result = root[inputKey];
+          // If result is undefined, it's a programming error since we initialize all input keys
+          if (result === undefined) {
+            console.warn(
+              `\u001b[33m\u001b[1m[Funkophile]\u001b[0m Input key "${inputKey}" is undefined in state, which shouldn't happen. Using empty object.`
+            );
+            return {};
+          }
+          return result;
+        }),
+      };
+    }, {})
+  );
+}
+
+export function startServing(funkophileConfig): void {
+  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;
+
+    // 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}/`
+    );
+  });
+
+  // Handle process exit to close the server
+  process.on("SIGINT", () => {
+    if (server) {
+      server.close();
+    }
+    // process.exit(0);
+  });
+}
+
+// Log all input keys to see if they're present
+export function logInputKeys(funkophileConfig, currentState) {
+  Object.keys(funkophileConfig.inputs).forEach((inputKey) => {
+    if (currentState[inputKey]) {
+      console.log(
+        `\u001b[36m\u001b[1m[Funkophile]\u001b[0m Input key "${inputKey}" found in state with ${
+          Object.keys(currentState[inputKey]).length
+        } files`
+      );
+      // Only log file names if there are files to avoid cluttering the output
+      if (Object.keys(currentState[inputKey]).length > 0) {
+        console.log(
+          `\u001b[36m\u001b[1m[Funkophile]\u001b[0m Files for "${inputKey}":`,
+          Object.keys(currentState[inputKey])
+        );
+      }
+    } else {
+      console.warn(
+        `\u001b[33m\u001b[1m[Funkophile]\u001b[0m Input key "${inputKey}" NOT found in state`
+      );
+    }
+  });
+}
+
+export function logDone(funkophileConfig, currentState) {
+  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}"`;
+  }
+}
+
+export function makePromissesArray(funkophileConfig, store) {
+  return 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<void>((fulfill, reject) => {
+      if (funkophileConfig.mode === "build") {
+        // Use the glob pattern we constructed earlier
+        // console.log(`[Funkophile] Searching for files matching pattern: ${globPattern}`);
+        // console.log(`[Funkophile] Input rule key: ${inputRuleKey}`);
+
+        glob(globPattern, { cwd: process.cwd() })
+          .then((files: string[]) => {
+            // console.log(`[Funkophile] Found ${files.length} files for ${inputRuleKey} (pattern: ${pattern}):`, files);
+            if (files.length === 0) {
+              console.warn(
+                `No files found for input key "${inputRuleKey}" with pattern "${globPattern}"`
+              );
+              // Even if no files are found, the key is already initialized in the state
+              // No need to dispatch anything
+            } 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") {
+        console.log(
+          `\u001b[36m\u001b[1m[Funkophile]\u001b[0m Setting up watcher for pattern: ${globPattern}`
+        );
+        console.log(
+          `\u001b[36m\u001b[1m[Funkophile]\u001b[0m Current working directory: ${process.cwd()}`
+        );
+
+        // First, process initial files using glob to ensure all files are loaded
+        glob(globPattern, { cwd: process.cwd() })
+          .then((files: string[]) => {
+            console.log(
+              `\u001b[36m\u001b[1m[Funkophile]\u001b[0m Found ${files.length} initial files for ${inputRuleKey}`
+            );
+            files.forEach((file) => {
+              const absoluteFilePath = path.resolve(process.cwd(), file);
+              console.log(
+                `\u001b[32m\u001b[1m[Funkophile]\u001b[0m Adding initial file: ${file}`
+              );
+              dispatchUpsert(
+                store,
+                inputRuleKey,
+                absoluteFilePath,
+                funkophileConfig.encodings
+              );
+            });
+
+            // Now set up the watcher
+            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(
+                  `\u001b[31m\u001b[1m[Funkophile]\u001b[0m Watcher error for pattern ${globPattern}:`,
+                  error
+                );
+                logger.watchError(globPattern);
+              })
+              .on("add", (filePath) => {
+                console.log(
+                  `\u001b[32m\u001b[1m[Funkophile]\u001b[0m File added: ${filePath}`
+                );
+                logger.watchAdd(filePath);
+                const absoluteFilePath = path.resolve(process.cwd(), filePath);
+                console.log(
+                  `\u001b[32m\u001b[1m[Funkophile]\u001b[0m Dispatching UPSERT for key: ${inputRuleKey}, file: ${absoluteFilePath}`
+                );
+                dispatchUpsert(
+                  store,
+                  inputRuleKey,
+                  absoluteFilePath,
+                  funkophileConfig.encodings
+                );
+              })
+              .on("change", (filePath) => {
+                console.log(
+                  `\u001b[33m\u001b[1m[Funkophile]\u001b[0m File changed: ${filePath}`
+                );
+                logger.watchChange(filePath);
+                const absoluteFilePath = path.resolve(process.cwd(), filePath);
+                console.log(
+                  `\u001b[33m\u001b[1m[Funkophile]\u001b[0m Dispatching UPSERT for key: ${inputRuleKey}, file: ${absoluteFilePath}`
+                );
+                dispatchUpsert(
+                  store,
+                  inputRuleKey,
+                  absoluteFilePath,
+                  funkophileConfig.encodings
+                );
+              })
+              .on("unlink", (filePath) => {
+                console.log(
+                  `\u001b[31m\u001b[1m[Funkophile]\u001b[0m File removed: ${filePath}`
+                );
+                logger.watchUnlink(filePath);
+                const absoluteFilePath = path.resolve(process.cwd(), filePath);
+                console.log(
+                  `\u001b[31m\u001b[1m[Funkophile]\u001b[0m Dispatching REMOVE for key: ${inputRuleKey}, file: ${absoluteFilePath}`
+                );
+                store.dispatch({
+                  type: REMOVE,
+                  payload: {
+                    key: inputRuleKey,
+                    file: absoluteFilePath,
+                  },
+                });
+              })
+              .on("unlinkDir", (filePath) => {
+                console.log(
+                  `\u001b[31m\u001b[1m[Funkophile]\u001b[0m Directory removed: ${filePath}`
+                );
+                logger.watchUnlink(filePath);
+              })
+              .on("raw", (event, path, details) => {
+                console.log(
+                  `\u001b[90m\u001b[1m[Funkophile]\u001b[0m Raw event: ${event} for path: ${path}`
+                );
+              });
+
+            console.log(
+              `\u001b[32m\u001b[1m[Funkophile]\u001b[0m Watcher is ready for pattern: ${globPattern}`
+            );
+            logger.watchReady(globPattern);
+            fulfill();
+          })
+          .catch((error) => {
+            console.error(
+              `\u001b[31m\u001b[1m[Funkophile]\u001b[0m Error processing initial files 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);
+      }
+    });
+  });
+}