funcs.js

(() => {
    "use strict";

    if (typeof modulePath === "undefined") {
        console.error("Path to modules is not specified. Please define a variable 'modulePath'");
        process.exit(1);
    }

    global.path = {
        src: "src/",
        assets: "assets/",
        tmp: "__tmp/",
        dist: "__dist/"
    };

    global.Func = new function () {
        const requireModule = (m) => require(modulePath + m);

        /**
         "concat": "^1.0.3",
         "create-file": "^1.0.1",
         "eslint": "^8.37.0",
         "glob-concat": "^1.0.3",
         "html-minifier": "^4.0.0",
         "jsonminify": "^0.4.2",
         "sass": "^1.60.0",
         "npm-check-updates": "^16.8.2",
         "read-file": "^0.2.0",
         "terser": "^5.16.8",
         "zip-dir": "^2.0.0"

         *
         * @type {object}
         */
        const module = {
            find: requireModule("glob-concat"),
            concat: requireModule("concat"),
            read: requireModule("read-file"),
            createFile: requireModule("create-file"),
            minifyHtml: requireModule("html-minifier").minify,
            minifyJson: requireModule("jsonminify"),
            terser: requireModule("terser"),
            sass: requireModule("sass"),
            fs: require("fs").promises,
            path: require("path"),
            request: require("https"),
            zip: requireModule("zip-dir"),
            exec: require("child_process").exec
        };

        /*
         * ################################
         * PRIVATE
         * ################################
         */

        /**
         * Finds the files matching the given list of definitions (files, glob path, ...)
         *
         * @param {Array} files
         * @returns {Promise}
         */
        const find = (files) => {
            return new Promise((resolve) => {
                module.find.sync(files);
                module.find(files, (err, matches) => {
                    if (err) {
                        throw err;
                    }
                    resolve(matches);
                });
            });
        };

        /**
         * Reads the content of the given file
         *
         * @param {string} src
         * @returns {Promise}
         */
        const readFile = (src) => {
            return new Promise((resolve) => {
                module.read(src, {encoding: "utf8"}, (err, content) => {
                    if (err) {
                        throw err;
                    }
                    resolve(content);
                });
            });
        };

        /**
         * Determines the files matching the given definition and calls the given function for each of the files,
         * Optionally Waits until the callback function is runned before proceeding to the next file
         *
         * @param {Array} files
         * @param {boolean} flatten ignore the path of the given files and put them directly into the destination
         * @param {function} func
         * @returns {Promise}
         */
        const proceedFiles = async (files, flatten = true, func) => {
            const matches = await find(files);

            for (const match of matches) {
                const info = {
                    absPath: match,
                    parsedPath: match.replace(new RegExp("^(" + path.src + "|" + path.tmp + ")", "i"), "")
                };

                info.fileName = info.parsedPath.split(/\//).pop();

                if (flatten) {
                    info.parsedPath = info.fileName;
                }

                if (info.fileName.search(/\./) > -1) { // only proceed files
                    info.ext = info.fileName.split(/\./).pop();
                    await func(info);
                }
            }
        };

        /*
         * ################################
         * PUBLIC
         * ################################
         */

        this.cmd = (command) => {
            return new Promise((resolve) => {
                if (typeof command === "object") {
                    command = command.join("&&");
                }

                module.exec(command, (error, stdout, stderr) => {
                    resolve({
                        stdout: stdout,
                        stderr: stderr
                    });
                });
            });
        };

        /**
         * Creates a zip file containing all files of the given directory
         *
         * @param {string} dir
         * @param {string} dest
         * @returns {Promise}
         */
        this.zipDirectory = (dir, dest) => {
            return new Promise((resolve, reject) => {
                module.zip(dir, {saveTo: dest}, (err) => {
                    if (err) {
                        reject();
                    } else {
                        resolve();
                    }
                });
            });
        };

        /**
         * Removes the content of the tmp and dist directory
         *
         * @returns {Promise}
         */
        this.cleanPre = () => {
            return this.measureTime(async (resolve) => {
                const zipFiles = (await module.fs.readdir(".")).filter((f) => f.endsWith(".zip"));
                await this.remove(zipFiles);

                await this.emptyDir(path.tmp);
                await this.emptyDir(path.dist);
                await this.createFile(path.tmp + "info.txt", new Date().toISOString());
                resolve();
            }, "Cleaned tmp and dist directories");
        };

        /**
         * Removes all files from the given directory
         *
         * @param dir
         */
        this.emptyDir = async (dir) => {
            try {
                const files = await module.fs.readdir(dir);
                for (const file of files) {
                    await this.remove([dir + file]);
                }
            } catch (e) {
                //
            }
        }

        /**
         * Removes the tmp directory
         *
         * @returns {Promise}
         */
        this.cleanPost = () => {
            return this.measureTime(async (resolve) => {
                await this.remove([path.tmp])
                resolve()
            }, "Cleaned tmp directory");
        };

        /**
         *
         * @param {function} func
         * @param {string} msg
         * @returns {Promise}
         */
        this.measureTime = async (func, msg) => {
            const start = +new Date();
            const info = await new Promise(func)
            const timeInfo = "[" + (+new Date() - start) + " ms]";
            console.log(" - " + timeInfo + "" + (" ".repeat(10 - timeInfo.length)) + msg + (info ? (" -> " + info) : ""));
        };

        /**
         * Creates a file with the given content
         *
         * @param {string} src
         * @param {string} content
         * @returns {Promise}
         */
        this.createFile = (src, content) => {
            return new Promise((resolve) => {
                this.remove([src]).then(() => { // remove existing file
                    setTimeout(() => {
                        module.createFile(src, content, (err) => { // create file with given content
                            if (err) {
                                throw err;
                            }
                            resolve();
                        });
                    }, 100);
                });
            });
        };

        /**
         * Replaces the given definitions in the content of the given files
         *
         * @param {object} files
         * @param {Array} replaces
         * @returns {Promise}
         */
        this.replace = (files, replaces) => {
            return new Promise((resolve) => {
                Object.keys(files).forEach((src) => {
                    readFile(src).then((content) => { // read file
                        replaces.forEach((replace) => { // replace the definitions
                            content = content.replace(replace[0], replace[1]);
                        });

                        return this.createFile(files[src], content); // save file with new content
                    }).then(() => {
                        resolve();
                    });
                });
            });
        };

        /**
         * Removes the given files
         *
         * @param {Array} files
         * @returns {Promise}
         */
        this.remove = async (files) => {
            for (const file of files) {
                await module.fs.rm(file, {recursive: true, force: true});
            }
        };

        /**
         * Merges the content of the given files into one output file
         *
         * @param {Array} files
         * @param {string} output
         * @returns {Promise}
         */
        this.concat = (files, output) => {
            return new Promise((resolve) => {
                find(files).then((matches) => {
                    return module.concat(matches, output);
                }).then(() => {
                    resolve();
                });
            });
        };

        /**
         * Copies the given files in the given destination
         *
         * @param {Array} files
         * @param {Array} exclude
         * @param {string} dest
         * @param {boolean} flatten ignore the path of the given files and put them directly into the destination
         * @returns {Promise}
         */
        this.copy = async (files, exclude, dest, flatten = true) => {
            const exludeList = await find(exclude);
            await proceedFiles(files, flatten, async (info) => {
                if (exludeList.indexOf(info.absPath) === -1) { // not excluded -> copy file
                    await module.fs.mkdir(module.path.dirname(dest + info.parsedPath), {recursive: true});
                    await module.fs.copyFile(info.absPath, dest + info.parsedPath)
                }
            });
        };

        /**
         * Returns the content of the given url
         *
         * @param {string} url
         * @returns {Promise}
         */
        this.getRemoteContent = (url) => {
            return new Promise((resolve, reject) => {
                module.request.get(url, {timeout: 5000}, (resp) => {
                    let data = "";

                    resp.on("data", (chunk) => { // a chunk of data has been received.
                        data += chunk;
                    });

                    resp.on("end", () => { // // The whole response has been received. Print out the result.
                        resolve(data);
                    });
                }).on("error", (err) => {
                    console.error(err);
                    reject();
                });
            });
        };

        /**
         * Minifies the given files and puts them in the given destination
         *
         * @param {Array} files
         * @param {string} dest
         * @param {boolean} flatten ignore the path of the given files and put them directly into the destination
         * @param {string} preamble for css and js files
         * @returns {Promise}
         */
        this.minify = async (files, dest, flatten = true, preamble) => {
            await proceedFiles(files, flatten, async (info) => {
                if (info.ext === "scss") { // minify by filename
                    if (!info.fileName.startsWith("_")) {
                        const result = module.sass.renderSync({
                            file: info.absPath,
                            outFile: info.absPath.replace(/\.scss$/, ".css"),
                            outputStyle: "compressed",
                            includePaths: [path.src + "scss", path.assets + "scss"]
                        });

                        info.parsedPath = info.parsedPath.replace(/^scss\//, "css/").replace(/\.scss$/, ".css");

                        let content = result.css.toString().trim();
                        if (preamble) {
                            content = `/*! ${preamble} */\n` + content;
                        }

                        await this.createFile(dest + info.parsedPath, content) // save file in the output directory
                    }
                } else { // read file and minify the retrieved content
                    let content = await readFile(info.absPath)
                    switch (info.ext) {
                        case "html": {
                            content = module.minifyHtml(content, { // minify content
                                collapseWhitespace: true,
                                removeComments: true,
                                keepClosingSlash: true,
                                minifyCSS: true
                            });
                            break;
                        }
                        case "json": {
                            content = module.minifyJson(content);
                            break;
                        }
                        case "js": {
                            const result = await module.terser.minify(content, {
                                output: {
                                    preamble: (() => {
                                        if (preamble) {
                                            return `/*! ${preamble} */`;
                                        }
                                        return null;
                                    })()
                                },
                                mangle: {
                                    reserved: ["jsu", "chrome"]
                                }
                            });
                            if (result.error) {
                                throw result.error;
                            }
                            content = result.code;
                            break;
                        }
                    }

                    await this.createFile(dest + info.parsedPath, content); // save file in the output directory
                }
            });
        };
    };

})();