funkophile 0.0.19 → 0.0.23

package/dist/esm/funkophileHelpers.js

@@ -10,7 +10,7 @@ export const contentOfFile = (selector) => {
             return selected[Object.keys(selected)[0]];
         }
         catch (e) {
-            console.error("error in contentOfFile", e);
+            console.error("error", e);
             console.error("selected", selected);
             console.error("selector", selector);
             process.exit(-1);

package/dist/esm/index.d.ts

@@ -1,2 +1,12 @@
-declare const _default: (funkophileConfig: any, mode: string) => void;
+declare const _default: (funkophileConfig: {
+    mode: "build" | "watch";
+    initialState: any;
+    options: {
+        inFolder: string;
+        outFolder: string;
+    };
+    encodings: Record<string, string[]>;
+    inputs: Record<string, string>;
+    outputs: (x: any) => any;
+}) => void;
 export default _default;

package/dist/esm/index.js

@@ -6,7 +6,8 @@ import fse from "fs-extra";
 import { glob } from "glob";
 import path from "path";
 import Promise from "bluebird";
-export default (funkophileConfig, mode) => {
+export default (funkophileConfig) => {
+    // if (funkophileConfig.mode)
     Promise.config({
         cancellation: true,
     });
@@ -53,13 +54,10 @@ export default (funkophileConfig, mode) => {
         }
     }
     const dispatchUpsert = (store, key, file, encodings) => {
-        const fileType = file.split(".").slice(-2, -1)[0];
-        let encoding = Object.keys(encodings).find((e) => encodings[e].includes(fileType));
-        if (!fileType || !encoding) {
-            console.log(`Unknown file type for `, file, `Defaulting to utf8`);
-            encoding = "utf8";
-        }
-        // console.log("dispatchUpsert", encoding, file)
+        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,
@@ -108,8 +106,7 @@ export default (funkophileConfig, mode) => {
                 };
             }
             else {
-                console.error("Redux was asked to handle an unknown action type: " +
-                    action.type);
+                console.error("Redux was asked to handle an unknown action type: " + action.type);
                 process.exit(-1);
             }
             // return state
@@ -122,11 +119,10 @@ export default (funkophileConfig, mode) => {
         };
     }, {}));
     // Wait for all the file watchers to check in
-    Promise.all(Object.keys(funkophileConfig.inputs)
-        .map((inputRuleKey) => {
+    Promise.all(Object.keys(funkophileConfig.inputs).map((inputRuleKey) => {
         const p = path.resolve(`./${funkophileConfig.options.inFolder}/${funkophileConfig.inputs[inputRuleKey] || ""}`);
         return new Promise((fulfill, reject) => {
-            if (mode === "build") {
+            if (funkophileConfig.mode === "build") {
                 glob(p, {})
                     .then((files) => {
                     files.forEach((file) => {
@@ -137,7 +133,7 @@ export default (funkophileConfig, mode) => {
                     fulfill();
                 });
             }
-            else if (mode === "watch") {
+            else if (funkophileConfig.mode === "watch") {
                 chokidar
                     .watch(p, {})
                     .on("error", (error) => {
@@ -173,7 +169,7 @@ export default (funkophileConfig, mode) => {
                 // })
             }
             else {
-                console.error(`The 3rd argument should be 'watch' or 'build', not "${mode}"`);
+                console.error(`mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`);
                 process.exit(-1);
             }
         });
@@ -245,10 +241,6 @@ export default (funkophileConfig, mode) => {
                                     // not called
                                 });
                             }
-                            else if (typeof contents === "object") {
-                                fse.outputFile(relativeFilePath, JSON.stringify(contents), fulfill);
-                                logger.writingString(relativeFilePath);
-                            }
                             else {
                                 console.log(`I don't recognize what this is but I will try to write it to a file: ` +
                                     relativeFilePath, typeof contents, contents);
@@ -263,14 +255,14 @@ export default (funkophileConfig, mode) => {
                 });
             })).then(() => {
                 cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
-                if (mode === "build") {
+                if (funkophileConfig.mode === "build") {
                     logger.done();
                 }
-                else if (mode === "watch") {
+                else if (funkophileConfig.mode === "watch") {
                     logger.waiting();
                 }
                 else {
-                    console.error(`The 3rd argument should be 'watch' or 'build', not "${mode}"`);
+                    console.error(`The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`);
                     process.exit(-1);
                 }
             });
@@ -283,23 +275,3 @@ export default (funkophileConfig, mode) => {
         });
     });
 };
-// export default () => {
-//   if (
-//     process.argv[2] &&
-//     (process.argv[3] === "watch" || process.argv[3] === "build")
-//   ) {
-//     const configFile = path.resolve(process.argv[2]);
-//     const mode = process.argv[3];
-//     // console.log("configfile", configFile);
-//     import(configFile).then((funkophileConfigModule) => {
-//       const funkophileConfig = funkophileConfigModule.default;
-//       // console.log("funkophileConfig", (funkophileConfig));
-//           });
-//   } else {
-//     console.error("command line arguments do not make sense");
-//     console.error("first argument should be a funkophile config file");
-//     console.error("second argument should be a 'build' or 'watch'");
-//     console.error("You passed", process.argv);
-//     process.exit(-1);
-//   }
-// };

package/funkophileHelpers.ts

@@ -8,16 +8,16 @@ export const contentsOfFiles = (selector) => {
 
 export const contentOfFile = (selector) => {
   return createSelector([selector], (selected) => {
-    try {
-      return selected[Object.keys(selected)[0]];
+    try{
+      return selected[Object.keys(selected)[0]]
     } catch (e) {
-      console.error("error in contentOfFile", e);
-      console.error("selected", selected);
-      console.error("selector", selector);
-      process.exit(-1);
+      console.error("error", e)
+      console.error("selected", selected)
+      console.error("selector", selector)
+      process.exit(-1)
     }
-  });
-};
+  })
+}
 
 export const srcAndContentOfFile = (selector, key: string) => {
   return createSelector([selector], (selected) => {

package/index.ts

@@ -3,396 +3,366 @@ import { createSelector } from "reselect";
 import { Action, createStore, Store } from "redux";
 import fs from "fs";
 import fse from "fs-extra";
-import {glob}  from "glob";
+import { glob } from "glob";
 import path from "path";
 import Promise from "bluebird";
 
-export default (funkophileConfig: any, mode: string) => {
-	Promise.config({
-		cancellation: true,
-	});
+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;
+}) => {
 
-	const INITIALIZE = "INITIALIZE";
-	const UPSERT = "UPSERT";
-	const REMOVE = "REMOVE";
+	// if (funkophileConfig.mode)
+  Promise.config({
+    cancellation: true,
+  });
 
-	const previousState: any = {};
-	let outputPromise = Promise.resolve();
+  const INITIALIZE = "INITIALIZE";
+  const UPSERT = "UPSERT";
+  const REMOVE = "REMOVE";
 
-	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),
+  const previousState: any = {};
+  let outputPromise = Promise.resolve();
 
-		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 "),
-	};
+  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),
 
-	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);
-			});
+    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 "),
+  };
 
-			// re-evaluate files; after deleting subfolder
-			// we may have parent folder empty now
-			files = fs.readdirSync(folder);
-		}
+  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);
+      });
 
-		if (files.length == 0) {
-			logger.cleaningEmptyfolder(folder);
+      // re-evaluate files; after deleting subfolder
+      // we may have parent folder empty now
+      files = fs.readdirSync(folder);
+    }
 
-			fs.rmdirSync(folder);
-			return;
-		}
-	}
+    if (files.length == 0) {
+      logger.cleaningEmptyfolder(folder);
 
-	const dispatchUpsert = (
-		store: Store,
-		key: string,
-		file: string,
-		encodings: Record<string, string[]>
-	) => {
-		const fileType: string = file.split(".").slice(-2, -1)[0] as string;
-		let encoding: BufferEncoding = Object.keys(encodings).find((e) =>
-			(encodings[e] as string[]).includes(fileType)
-		) as BufferEncoding;
+      fs.rmdirSync(folder);
+      return;
+    }
+  }
 
-		if (!fileType || !encoding) {
-			console.log(`Unknown file type for `, file, `Defaulting to utf8`);
-			encoding = "utf8";
-		}
-		// console.log("dispatchUpsert", encoding, file)
-		logger.readingFile(file);
-		store.dispatch({
-			type: UPSERT,
-			payload: {
-				key: key,
-				src: file,
-				contents: fse.readFileSync(file, encoding),
-			},
-		});
-	};
+  const dispatchUpsert = (
+    store: Store,
+    key: string,
+    file: string,
+    encodings: Record<string, string[]>
+  ) => {
 
-	function omit(key: string, obj: any) {
-		const { [key]: omitted, ...rest } = obj;
-		return rest;
-	}
+    const fileType: string = path.basename(file).split(".")[1];
 
-	const store: Store<any, Action<string>, any> = createStore(
-		(
-			state = {
-				initialLoad: true,
-				...funkophileConfig.initialState,
-				timestamp: Date.now(),
-			},
-			action
-		) => {
-			// 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]: {
-							...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
-			}
-		}
-	);
+    let encoding: BufferEncoding = Object.keys(encodings).find((e) => {
+      return encodings[e].includes(fileType);
+    }) as BufferEncoding;
 
-	const finalSelector = funkophileConfig.outputs(
-		Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
-			return {
-				...mm,
-				[inputKey]: createSelector([(x) => x], (root) => root[inputKey]),
-			};
-		}, {})
-	);
+    logger.readingFile(file);
+    store.dispatch({
+      type: UPSERT,
+      payload: {
+        key: key,
+        src: file,
+        contents: fse.readFileSync(file, encoding),
+      },
+    });
+  };
 
-	// 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] || ""
-				}`
-			);
+  function omit(key: string, obj: any) {
+    const { [key]: omitted, ...rest } = obj;
+    return rest;
+  }
 
-			return new Promise((fulfill, reject) => {
-				if (mode === "build") {
-					glob(p, {})
-						.then((files: string[]) => {
-							files.forEach((file) => {
-								dispatchUpsert(
-									store,
-									inputRuleKey,
-									file,
-									funkophileConfig.encodings
-								);
-							});
-						})
-						.then(() => {
-							fulfill();
-						});
-				} else if (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);
-					// })
-				} else {
-					console.error(
-						`The 3rd argument should be 'watch' or 'build', not "${mode}"`
-					);
-					process.exit(-1);
-				}
-			});
-		})
-	).then(function () {
-		// listen for changes to the store
-		store.subscribe(() => {
-			const s = store.getState();
+  const store: Store<any, Action<string>, any> = createStore(
+    (
+      state = {
+        initialLoad: true,
+        ...funkophileConfig.initialState,
+        timestamp: Date.now(),
+      },
+      action
+    ) => {
+      // 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]: {
+              ...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
+      }
+    }
+  );
 
-			logger.stateChange();
-			const outputs = finalSelector(s);
+  const finalSelector = funkophileConfig.outputs(
+    Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
+      return {
+        ...mm,
+        [inputKey]: createSelector([(x) => x], (root) => root[inputKey]),
+      };
+    }, {})
+  );
 
-			if (outputPromise.isPending()) {
-				console.log("cancelling previous write!");
-				outputPromise.cancel();
-			}
+  // 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] || ""
+        }`
+      );
 
-			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);
+      return new Promise((fulfill, reject) => {
+        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);
+          // })
+        } else {
+          console.error(
+            `mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`
+          );
+          process.exit(-1);
+        }
+      });
+    })
+  ).then(function () {
+    // listen for changes to the store
+    store.subscribe(() => {
+      const s = store.getState();
 
-							try {
-								fse.unlinkSync("./" + file);
-								cleanEmptyFoldersRecursively(
-									"./" + file.substring(0, file.lastIndexOf("/"))
-								);
-							} catch (ex) {
-								// console.error('inner', ex.message);
-								// throw ex;
-							} finally {
-								// console.log('finally');
-								return;
-							}
-							// delete previousState[key]
-							// fulfill()
-						} else {
-							if (outputs[key] !== previousState[key]) {
-								previousState[key] = outputs[key];
+      logger.stateChange();
+      const outputs = finalSelector(s);
 
-								const relativeFilePath =
-									"./" + funkophileConfig.options.outFolder + "/" + key;
-								const contents = outputs[key];
+      if (outputPromise.isPending()) {
+        console.log("cancelling previous write!");
+        outputPromise.cancel();
+      }
 
-								if (typeof contents === "function") {
-									logger.writingFunction(relativeFilePath);
-									contents((err, res) => {
-										fse.outputFile(relativeFilePath, res, fulfill);
-										logger.writingString(relativeFilePath);
-									});
-								} else if (typeof contents === "string") {
-									fse.outputFile(relativeFilePath, contents, fulfill);
-									logger.writingString(relativeFilePath);
-								} else if (Buffer.isBuffer(contents)) {
-									fse.outputFile(relativeFilePath, contents, fulfill);
-									logger.writingString(relativeFilePath);
-								} else if (Array.isArray(contents)) {
-									fse.outputFile(
-										relativeFilePath,
-										JSON.stringify(contents),
-										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
-												);
-											} else {
-												fse.outputFile(relativeFilePath, value, fulfill);
-												logger.writingString(relativeFilePath);
-											}
-										},
-										function (value) {
-											// not called
-										}
-									);
-								} else if (typeof contents === "object") {
-									fse.outputFile(
-										relativeFilePath,
-										JSON.stringify(contents),
-										fulfill
-									);
-									logger.writingString(relativeFilePath);
-								} else {
-									console.log(
-										`I don't recognize what this is but I will try to write it to a file: ` +
-											relativeFilePath,
-										typeof contents,
-										contents
-									);
-									fse.outputFile(relativeFilePath, contents, fulfill);
-									logger.writingString(relativeFilePath);
-								}
-							} else {
-								fulfill();
-							}
-						}
-					});
-				})
-			).then(() => {
-				cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
+      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);
 
-				if (mode === "build") {
-					logger.done();
-				} else if (mode === "watch") {
-					logger.waiting();
-				} else {
-					console.error(
-						`The 3rd argument should be 'watch' or 'build', not "${mode}"`
-					);
-					process.exit(-1);
-				}
-			});
-		});
+              try {
+                fse.unlinkSync("./" + file);
+                cleanEmptyFoldersRecursively(
+                  "./" + file.substring(0, file.lastIndexOf("/"))
+                );
+              } catch (ex) {
+                // console.error('inner', ex.message);
+                // throw ex;
+              } finally {
+                // console.log('finally');
+                return;
+              }
+              // delete previousState[key]
+              // fulfill()
+            } else {
+              if (outputs[key] !== previousState[key]) {
+                previousState[key] = outputs[key];
 
-		// lastly, turn the store `on`.
-		// This is to prevent unecessary recomputations when initialy adding files to redux
-		store.dispatch({
-			type: INITIALIZE,
-			payload: true,
-		});
-	});
+                const relativeFilePath =
+                  "./" + funkophileConfig.options.outFolder + "/" + key;
+                const contents = outputs[key];
 
-}
-// export default () => {
-//   if (
-//     process.argv[2] &&
-//     (process.argv[3] === "watch" || process.argv[3] === "build")
-//   ) {
-//     const configFile = path.resolve(process.argv[2]);
-//     const mode = process.argv[3];
+                if (typeof contents === "function") {
+                  logger.writingFunction(relativeFilePath);
+                  contents((err, res) => {
+                    fse.outputFile(relativeFilePath, res, fulfill);
+                    logger.writingString(relativeFilePath);
+                  });
+                } else if (typeof contents === "string") {
+                  fse.outputFile(relativeFilePath, contents, fulfill);
+                  logger.writingString(relativeFilePath);
+                } else if (Buffer.isBuffer(contents)) {
+                  fse.outputFile(relativeFilePath, contents, fulfill);
+                  logger.writingString(relativeFilePath);
+                } else if (Array.isArray(contents)) {
+                  fse.outputFile(
+                    relativeFilePath,
+                    JSON.stringify(contents),
+                    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);
+                      } else {
+                        fse.outputFile(relativeFilePath, value, fulfill);
+                        logger.writingString(relativeFilePath);
+                      }
+                    },
+                    function (value) {
+                      // not called
+                    }
+                  );
+                } else {
+                  console.log(
+                    `I don't recognize what this is but I will try to write it to a file: ` +
+                      relativeFilePath,
+                    typeof contents,
+                    contents
+                  );
+                  fse.outputFile(relativeFilePath, contents, fulfill);
+                  logger.writingString(relativeFilePath);
+                }
+              } else {
+                fulfill();
+              }
+            }
+          });
+        })
+      ).then(() => {
+        cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
 
-//     // console.log("configfile", configFile);
-//     import(configFile).then((funkophileConfigModule) => {
-//       const funkophileConfig = funkophileConfigModule.default;
-//       // console.log("funkophileConfig", (funkophileConfig));
-//           });
-//   } else {
-//     console.error("command line arguments do not make sense");
-//     console.error("first argument should be a funkophile config file");
-//     console.error("second argument should be a 'build' or 'watch'");
-//     console.error("You passed", process.argv);
-//     process.exit(-1);
-//   }
-// };
+        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);
+        }
+      });
+    });
+
+    // lastly, turn the store `on`.
+    // This is to prevent unecessary recomputations when initialy adding files to redux
+    store.dispatch({
+      type: INITIALIZE,
+      payload: true,
+    });
+  });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "funkophile",
-  "version": "0.0.19",
+  "version": "0.0.23",
   "repository": "git@github.com:adamwong246/funkophile.git",
   "author": "adam wong <adamwong246@gmail.com>",
   "license": "MIT",