funkophile 0.0.2 → 0.0.4

package/funkophileHelpers.d.ts

@@ -0,0 +1,108 @@
+export declare const contentsOfFiles: (selector: any) => ((state: unknown) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: any) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: any) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const contentOfFile: (selector: any) => ((state: unknown) => any) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: any) => any;
+    memoizedResultFunc: ((resultFuncArgs_0: any) => any) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => any;
+    dependencies: [any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const srcAndContentOfFile: (selector: any, key: string) => ((state: unknown) => {
+    src: string;
+    content: any;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: any) => {
+        src: string;
+        content: any;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: any) => {
+        src: string;
+        content: any;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        src: string;
+        content: any;
+    };
+    dependencies: [any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const srcAndContentOfFiles: (selector: any) => ((state: unknown) => {
+    src: string;
+    content: any;
+}[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: any) => {
+        src: string;
+        content: any;
+    }[];
+    memoizedResultFunc: ((resultFuncArgs_0: any) => {
+        src: string;
+        content: any;
+    }[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        src: string;
+        content: any;
+    }[];
+    dependencies: [any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/funkophileHelpers.js

@@ -1,44 +1,45 @@
-const createSelector = require('reselect').createSelector;
-
-module.exports = {
-
-	contentsOfFiles: (selector) => {
-		return createSelector([selector], (selected) => {
-			return Object.keys(selected).reduce((mm, k) => mm + selected[k], '')
-		})
-	},
-
-	contentOfFile: (selector) => {
-		return createSelector([selector], (selected) => {
-			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)
-      }
-		})
-	},
-
-	srcAndContentOfFile: (selector, key) => {
-		return createSelector([selector], (selected) => {
-			return {
-				src: key,
-				content: selected[key]
-			}
-		})
-	},
-
-	srcAndContentOfFiles: (selector) => {
-		return createSelector([selector], (selected) => {
-			const keys = Object.keys(selected)
-			return keys.map((key) => {
-				return {
-					src: key,
-					content: selected[key]
-				}
-			})
-		})
-	}
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.srcAndContentOfFiles = exports.srcAndContentOfFile = exports.contentOfFile = exports.contentsOfFiles = void 0;
+var reselect_1 = require("reselect");
+var contentsOfFiles = function (selector) {
+    return (0, reselect_1.createSelector)([selector], function (selected) {
+        return Object.keys(selected).reduce(function (mm, k) { return mm + selected[k]; }, "");
+    });
+};
+exports.contentsOfFiles = contentsOfFiles;
+var contentOfFile = function (selector) {
+    return (0, reselect_1.createSelector)([selector], function (selected) {
+        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);
+        }
+    });
+};
+exports.contentOfFile = contentOfFile;
+var srcAndContentOfFile = function (selector, key) {
+    return (0, reselect_1.createSelector)([selector], function (selected) {
+        return {
+            src: key,
+            content: selected[key],
+        };
+    });
+};
+exports.srcAndContentOfFile = srcAndContentOfFile;
+var srcAndContentOfFiles = function (selector) {
+    return (0, reselect_1.createSelector)([selector], function (selected) {
+        var keys = Object.keys(selected);
+        return keys.map(function (key) {
+            return {
+                src: key,
+                content: selected[key],
+            };
+        });
+    });
+};
+exports.srcAndContentOfFiles = srcAndContentOfFiles;

package/funkophileHelpers.ts

@@ -0,0 +1,41 @@
+import { createSelector } from "reselect";
+
+export const contentsOfFiles = (selector) => {
+  return createSelector([selector], (selected) => {
+    return Object.keys(selected).reduce((mm, k) => mm + selected[k], "");
+  });
+};
+
+export const contentOfFile = (selector) => {
+  return createSelector([selector], (selected) => {
+    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);
+    }
+  });
+};
+
+export const srcAndContentOfFile = (selector, key: string) => {
+  return createSelector([selector], (selected) => {
+    return {
+      src: key,
+      content: selected[key],
+    };
+  });
+};
+
+export const srcAndContentOfFiles = (selector) => {
+  return createSelector([selector], (selected) => {
+    const keys = Object.keys(selected);
+    return keys.map((key) => {
+      return {
+        src: key,
+        content: selected[key],
+      };
+    });
+  });
+};

package/index.d.ts

@@ -0,0 +1 @@
+export {};

package/index.js

@@ -1,329 +1,300 @@
-// funkophile/index.js
-
-const chokidar = require('chokidar');
-const createSelector = require('reselect').createSelector;
-const createStore = require('redux').createStore;
-const fs = require("fs")
-const fse = require("fs-extra")
-const glob = require("glob-promise");
-const path = require("path")
-const Promise = require("bluebird")
-
-Promise.config({
-	cancellation: true
-});
-
-const configFile = path.resolve(process.argv[2]);
-const funkophileConfig = require(configFile)
-const mode = process.argv[3]
-const keyToWatch = process.argv[4]
-
-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) => {
-	logger.readingFile(file)
-	store.dispatch({
-		type: UPSERT,
-		payload: {
-			key: key,
-			src: file,
-			contents: fse.readFileSync(file, Object.keys(encodings).find((e) => encodings[e].includes(file.split('.')[1])))
-		}
-	});
-
-	// const filetype = file.split('.')[2]
-	// const encoding = Object.keys(encodings).find((e) => encodings[e].includes(filetype))
-	// const relativeFilePath = './' + file;
-	// console.log("\u001b[31m <-- \u001b[0m" + file)
-	// fse.readFile(file, encoding).then((contents) => {
-	//   store.dispatch({
-	//     type: UPSERT,
-	//     payload: {
-	//       key: key,
-	//       src: file,
-	//       contents: contents
-	//     }
-	//   });
-	// });
-
-
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
 };
-
-function omit(key, obj) {
-	const {
-		[key]: omitted, ...rest
-	} = obj;
-	return rest;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var chokidar_1 = require("chokidar");
+var reselect_1 = require("reselect");
+var redux_1 = require("redux");
+var fs_1 = require("fs");
+var fs_extra_1 = require("fs-extra");
+var glob_promise_1 = require("glob-promise");
+var path_1 = require("path");
+var bluebird_1 = require("bluebird");
+if (process.argv[2] && (process.argv[3] === "watch" || process.argv[3] === "build")) {
+    var configFile = path_1.default.resolve(process.argv[2]);
+    var mode_1 = process.argv[3];
+    // console.log("configfile", configFile);
+    Promise.resolve("".concat(configFile)).then(function (s) { return require(s); }).then(function (funkophileConfigModule) {
+        var funkophileConfig = funkophileConfigModule.default;
+        // console.log("funkophileConfig", (funkophileConfig));
+        bluebird_1.default.config({
+            cancellation: true
+        });
+        var INITIALIZE = 'INITIALIZE';
+        var UPSERT = 'UPSERT';
+        var REMOVE = 'REMOVE';
+        var previousState = {};
+        var outputPromise = bluebird_1.default.resolve();
+        var logger = {
+            watchError: function (p) { return console.log("\u001b[7m ! \u001b[0m" + p); },
+            watchReady: function (p) { return console.log("\u001b[7m\u001b[36m  <  \u001b[0m" + p); },
+            watchAdd: function (p) { return console.log("\u001b[7m\u001b[34m  +  \u001b[0m./" + p); },
+            watchChange: function (p) { return console.log("\u001b[7m\u001b[35m  *  \u001b[0m" + p); },
+            watchUnlink: function (p) { return console.log("\u001b[7m\u001b[31m  -  \u001b[0m./" + p); },
+            stateChange: function () { return console.log("\u001b[7m\u001b[31m --- Redux state changed --- \u001b[0m"); },
+            cleaningEmptyfolder: function (p) { return console.log("\u001b[31m\u001b[7m XXX! \u001b[0m" + p); },
+            readingFile: function (p) { return console.log("\u001b[31m <-- \u001b[0m" + p); },
+            removedFile: function (p) { return console.log("\u001b[31m\u001b[7m ??? \u001b[0m./" + p); },
+            writingString: function (p) { return console.log("\u001b[32m --> \u001b[0m" + p); },
+            writingFunction: function (p) { return console.log("\u001b[33m ... \u001b[0m" + p); },
+            writingPromise: function (p) { return console.log("\u001b[33m ... \u001b[0m" + p); },
+            writingError: function (p, message) { return console.log("\u001b[31m !!! \u001b[0m" + p + " " + message); },
+            waiting: function () { return console.log("\u001b[7m Funkophile is done for now but waiting on changes...\u001b[0m "); },
+            done: function () { return console.log("\u001b[7m Funkophile is done!\u001b[0m "); }
+        };
+        function cleanEmptyFoldersRecursively(folder) {
+            var isDir = fs_1.default.statSync(folder).isDirectory();
+            if (!isDir) {
+                return;
+            }
+            var files = fs_1.default.readdirSync(folder);
+            if (files.length > 0) {
+                files.forEach(function (file) {
+                    var fullPath = path_1.default.join(folder, file);
+                });
+                // re-evaluate files; after deleting subfolder
+                // we may have parent folder empty now
+                files = fs_1.default.readdirSync(folder);
+            }
+            if (files.length == 0) {
+                logger.cleaningEmptyfolder(folder);
+                fs_1.default.rmdirSync(folder);
+                return;
+            }
+        }
+        var dispatchUpsert = function (store, key, file, encodings) {
+            var fileType = file.split('.').slice(-2, -1)[0];
+            var encoding = Object.keys(encodings).find(function (e) { return encodings[e].includes(fileType); });
+            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: fs_extra_1.default.readFileSync(file, encoding)
+                }
+            });
+        };
+        function omit(key, obj) {
+            var _a = obj, _b = key, omitted = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+            return rest;
+        }
+        var store = (0, redux_1.createStore)(function (state, action) {
+            var _a, _b, _c;
+            if (state === void 0) { state = __assign(__assign({ initialLoad: true }, funkophileConfig.initialState), { timestamp: Date.now() }); }
+            // console.log("\u001b[7m\u001b[35m ||| Redux recieved action \u001b[0m", action.type)
+            if (!action.type.includes('@@redux')) {
+                if (action.type === INITIALIZE) {
+                    return __assign(__assign({}, state), { initialLoad: false, timestamp: Date.now() });
+                }
+                else if (action.type === UPSERT) {
+                    return __assign(__assign({}, state), (_a = {}, _a[action['payload'].key] = __assign(__assign({}, state[action.payload.key]), (_b = {},
+                        _b[action['payload'].src] = action['payload'].contents,
+                        _b)), _a.timestamp = Date.now(), _a));
+                }
+                else if (action.type === REMOVE) {
+                    return __assign(__assign({}, state), (_c = {}, _c[action['payload'].key] = omit(action['payload'].file, state[action['payload'].key]), _c.timestamp = Date.now(), _c));
+                }
+                else {
+                    console.error("Redux was asked to handle an unknown action type: " + action.type);
+                    process.exit(-1);
+                }
+                // return state
+            }
+        });
+        var finalSelector = funkophileConfig.outputs(Object.keys(funkophileConfig.inputs).reduce(function (mm, inputKey) {
+            var _a;
+            return __assign(__assign({}, mm), (_a = {}, _a[inputKey] = (0, reselect_1.createSelector)([function (x) { return x; }], function (root) { return root[inputKey]; }), _a));
+        }, {}));
+        // Wait for all the file watchers to check in
+        bluebird_1.default.all(Object.keys(funkophileConfig.inputs)
+            .map(function (inputRuleKey) {
+            var p = path_1.default.resolve("./".concat(funkophileConfig.options.inFolder, "/").concat(funkophileConfig.inputs[inputRuleKey] || ''));
+            return new bluebird_1.default(function (fulfill, reject) {
+                if (mode_1 === "build") {
+                    (0, glob_promise_1.default)(p, {}).then(function (files) {
+                        files.forEach(function (file) {
+                            dispatchUpsert(store, inputRuleKey, file, funkophileConfig.encodings);
+                        });
+                    }).then(function () {
+                        fulfill();
+                    });
+                }
+                else if (mode_1 === "watch") {
+                    chokidar_1.default.watch(p, {})
+                        .on('error', function (error) {
+                        logger.watchError(p);
+                    })
+                        .on('ready', function () {
+                        logger.watchReady(p);
+                        fulfill();
+                    })
+                        .on('add', function (p) {
+                        logger.watchAdd(p);
+                        dispatchUpsert(store, inputRuleKey, './' + p, funkophileConfig.encodings);
+                    })
+                        .on('change', function (p) {
+                        logger.watchChange(p);
+                        dispatchUpsert(store, inputRuleKey, './' + p, funkophileConfig.encodings);
+                    })
+                        .on('unlink', function (p) {
+                        logger.watchUnlink(p);
+                        store.dispatch({
+                            type: REMOVE,
+                            payload: {
+                                key: inputRuleKey,
+                                file: './' + p
+                            }
+                        });
+                    })
+                        .on('unlinkDir', function (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 \"".concat(mode_1, "\""));
+                    process.exit(-1);
+                }
+            });
+        })).then(function () {
+            // listen for changes to the store
+            store.subscribe(function () {
+                var s = store.getState();
+                logger.stateChange();
+                var outputs = finalSelector(s);
+                if (outputPromise.isPending()) {
+                    console.log('cancelling previous write!');
+                    outputPromise.cancel();
+                }
+                outputPromise = bluebird_1.default.all(Array.from(new Set(Object.keys(previousState).concat(Object.keys(outputs))))
+                    .map(function (key) {
+                    return new bluebird_1.default(function (fulfill, reject) {
+                        if (!outputs[key]) {
+                            var file = funkophileConfig.options.outFolder + "/" + key;
+                            logger.removedFile(file);
+                            try {
+                                fs_extra_1.default.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];
+                                var relativeFilePath_1 = './' + funkophileConfig.options.outFolder + "/" + key;
+                                var contents = outputs[key];
+                                if (typeof contents === "function") {
+                                    logger.writingFunction(relativeFilePath_1);
+                                    contents(function (err, res) {
+                                        fs_extra_1.default.outputFile(relativeFilePath_1, res, fulfill);
+                                        logger.writingString(relativeFilePath_1);
+                                    });
+                                }
+                                else if (typeof contents === 'string') {
+                                    fs_extra_1.default.outputFile(relativeFilePath_1, contents, fulfill);
+                                    logger.writingString(relativeFilePath_1);
+                                }
+                                else if (Buffer.isBuffer(contents)) {
+                                    fs_extra_1.default.outputFile(relativeFilePath_1, contents, fulfill);
+                                    logger.writingString(relativeFilePath_1);
+                                }
+                                else if (Array.isArray(contents)) {
+                                    fs_extra_1.default.outputFile(relativeFilePath_1, JSON.stringify(contents), fulfill);
+                                    logger.writingString(relativeFilePath_1);
+                                }
+                                else if (typeof contents.then === 'function') {
+                                    logger.writingPromise(relativeFilePath_1);
+                                    bluebird_1.default.resolve(contents).then(function (value) {
+                                        if (value instanceof Error) {
+                                            logger.writingError(relativeFilePath_1, value.message);
+                                        }
+                                        else {
+                                            fs_extra_1.default.outputFile(relativeFilePath_1, value, fulfill);
+                                            logger.writingString(relativeFilePath_1);
+                                        }
+                                    }, function (value) {
+                                        // not called
+                                    });
+                                }
+                                else if (typeof contents === 'object') {
+                                    fs_extra_1.default.outputFile(relativeFilePath_1, JSON.stringify(contents), fulfill);
+                                    logger.writingString(relativeFilePath_1);
+                                }
+                                else {
+                                    console.log("I don't recognize what this is but I will try to write it to a file: " + relativeFilePath_1, typeof contents, contents);
+                                    fs_extra_1.default.outputFile(relativeFilePath_1, contents, fulfill);
+                                    logger.writingString(relativeFilePath_1);
+                                }
+                            }
+                            else {
+                                fulfill();
+                            }
+                        }
+                    });
+                })).then(function () {
+                    cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
+                    if (mode_1 === "build") {
+                        logger.done();
+                    }
+                    else if (mode_1 === "watch") {
+                        logger.waiting();
+                    }
+                    else {
+                        console.error("The 3rd argument should be 'watch' or 'build', not \"".concat(mode_1, "\""));
+                        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
+            });
+        });
+    });
+}
+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);
 }
-
-const store = 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
-	}
-})
-
-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)
-	// ['FUNKYBUNDLE']
-.map((inputRuleKey) => {
-	const p = path.resolve(`./${funkophileConfig.options.inFolder}/${funkophileConfig.inputs[inputRuleKey] || ''}`)
-
-	// console.log("mark3", p)
-
-	return new Promise((fulfill, reject) => {
-		if (mode === "build") {
-			glob(p, {}).then((files) => {
-				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()
-
-		logger.stateChange()
-		const outputs = finalSelector(s)
-
-		if (outputPromise.isPending()) {
-			console.log('cancelling previous write!')
-			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)
-
-						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]
-
-							const relativeFilePath = './' + funkophileConfig.options.outFolder + "/" + key;
-							const contents = outputs[key];
-
-							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, contents)
-								fse.outputFile(relativeFilePath, JSON.stringify(contents, null, 2), fulfill);
-								logger.writingString(relativeFilePath);
-							}
-						} else {
-							fulfill()
-						}
-					}
-				});
-
-			})
-		).then(() => {
-			cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
-
-			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)
-			}
-
-		})
-	})
-
-	// lastly, turn the store `on`.
-	// This is to prevent unecessary recomputations when initialy adding files to redux
-	store.dispatch({
-		type: INITIALIZE,
-		payload: true
-	});
-
-})

package/index.ts

@@ -0,0 +1,343 @@
+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-promise";
+import path from "path"
+import Promise from "bluebird"
+
+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));
+	Promise.config({
+		cancellation: true
+	});
+
+	const INITIALIZE = 'INITIALIZE';
+	const UPSERT = 'UPSERT';
+	const REMOVE = 'REMOVE';
+
+	const previousState: any = {}
+	let outputPromise = Promise.resolve();
+
+	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;
+		}
+	}
+
+	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;
+
+		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
+				)
+			}
+		});
+	};
+
+	function omit(key: string, obj: any) {
+		const {
+			[key]: omitted, ...rest
+		} = obj;
+		return rest;
+	}
+
+	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
+		}
+	})
+
+	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] || ''}`)
+
+
+				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()
+
+					logger.stateChange()
+					const outputs = finalSelector(s)
+
+					if (outputPromise.isPending()) {
+						console.log('cancelling previous write!')
+						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)
+
+										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]
+
+											const relativeFilePath = './' + funkophileConfig.options.outFolder + "/" + key;
+											const contents = outputs[key];
+
+											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);
+
+						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)
+						}
+
+					})
+				})
+
+				// lastly, turn the store `on`.
+				// This is to prevent unecessary recomputations when initialy adding files to redux
+				store.dispatch({
+					type: INITIALIZE,
+					payload: true
+				});
+
+			})
+
+})
+
+} 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/package.json

@@ -1,8 +1,32 @@
 {
   "name": "funkophile",
-  "version": "0.0.2",
-  "main": "index.js",
+  "version": "0.0.4",
   "repository": "git@github.com:adamwong246/funkophile.git",
   "author": "adam wong <adamwong246@gmail.com>",
-  "license": "MIT"
+  "license": "MIT",
+  "type": "module",
+  "main": "index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "help": "cat help.txt",
+    "transpile": "tsc --declaration index.ts funkophileHelpers.ts"
+  },
+  "dependencies": {
+    "@tsconfig/node-lts-strictest-esm": "^18.12.1",
+    "@types/bluebird": "^3.5.42",
+    "@types/chokidar": "^2.1.7",
+    "@types/fs-extra": "^11.0.4",
+    "@types/redux": "^3.6.0",
+    "@types/reselect": "^2.2.0",
+    "tsc": "^2.0.4",
+    "typescript": "^5.8.2"
+  },
+  "exports": {
+    "./index": {
+      "import": "./index.ts"
+    },
+    "./funkophileHelpers": {
+      "import": "./funkophileHelpers.ts"
+    }
+  }
 }

package/tsconfig.json

@@ -0,0 +1,11 @@
+{   
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/node-lts-strictest-esm/tsconfig.json",
+
+  "include": [
+    "*.ts"
+  ],   
+  "ts-node": {
+    "esm": true, // 
+  }
+}