fscr 6.2.3 → 7.3.0

package/dist/lib/release/validateNotDev.js

@@ -9,55 +9,63 @@ import { boxInform } from "../utils/helpers.js";
 import git from "git-state";
 import simple from "simple-git";
 const pathToCwd = process.cwd();
+
 const newBranch = async name => {
-  // const last = await new Promise(rzz => {
-  //     git.isGit(pathToCwd, function(exists) {
-  //         if (!exists) return;
-  //
-  //         git.commit(pathToCwd, function(err, result) {
-  //             if (err) throw err;
-  //             rzz(result);
-  //         });
-  //     });
-  // });
+    // const last = await new Promise(rzz => {
+    //     git.isGit(pathToCwd, function(exists) {
+    //         if (!exists) return;
+    //
+    //         git.commit(pathToCwd, function(err, result) {
+    //             if (err) throw err;
+    //             rzz(result);
+    //         });
+    //     });
+    // });
 
-  // await simple().checkoutLocalBranch(name);
-  await simple().checkoutBranch(name, "origin/Development");
-  boxInform(chalk.green(`New branch ${name} created`, "", 5));
+    // await simple().checkoutLocalBranch(name);
+    await simple().checkoutBranch(name, "origin/Development");
+    boxInform(chalk.green(`New branch ${name} created`, "", 5));
 };
+
 async function pub() {
-  return new Promise(resolve => {
-    inquirer.prompt([{
-      type: "input",
-      message: chalk.bold.hex("#38be18")(`Name new feature branch (or type cancel):`),
-      name: "branchname"
-    }]).then(async ({
-      branchname
-    }) => {
-      if (branchname !== "Development") await newBranch(branchname);
-      resolve();
+    return new Promise(resolve => {
+        inquirer
+            .prompt([
+                {
+                    type: "input",
+                    message: chalk.bold.hex("#38be18")(`Name new feature branch (or type cancel):`),
+                    name: "branchname"
+                }
+            ])
+            .then(async ({ branchname }) => {
+                if (branchname !== "Development") await newBranch(branchname);
+                resolve();
+            });
     });
-  });
 }
+
 const validateNotInDev = async () => {
-  await new Promise(async resolve => {
-    const {
-      default: git
-    } = await import("simple-git/promise");
-    let statusSummary = await git(__dirname).status();
-    if (statusSummary.current === "Development") {
-      console.clear();
-      console.log(boxen(chalk.bold.underline.red("DO NO MAKE CHANGES IN DEV!"), {
-        padding: 2
-      }));
-      await new Promise(resolve1 => setTimeout(() => {
-        resolve1();
-      }, 1000));
-      await pub();
-      resolve();
-    } else {
-      resolve();
-    }
-  });
+    await new Promise(async resolve => {
+        const { default: git } = await import("simple-git/promise");
+
+        let statusSummary = await git(__dirname).status();
+        if (statusSummary.current === "Development") {
+            console.clear();
+            console.log(
+                boxen(chalk.bold.underline.red("DO NO MAKE CHANGES IN DEV!"), {
+                    padding: 2
+                })
+            );
+            await new Promise(resolve1 =>
+                setTimeout(() => {
+                    resolve1();
+                }, 1000)
+            );
+            await pub();
+            resolve();
+        } else {
+            resolve();
+        }
+    });
 };
-export default validateNotInDev;
+export default validateNotInDev;

package/dist/lib/running/index.js

@@ -1,3 +1,3 @@
 export { default as runSequence } from "./runSequence.js";
 export { default as runParallel } from "./runParallel.js";
-export { default as runCLICommand } from "./runCLICommand.js";
+export { default as runCLICommand } from "./runCLICommand.js";

package/dist/lib/running/runCLICommand.js

@@ -3,36 +3,46 @@ import path from "path";
 import moment from "moment-mini";
 import spawn from "cross-spawn";
 import requireFromString from "require-from-string";
-export default async ({
-  script,
-  task,
-  type = script.type
-}, quiet = false) => {
-  if (!quiet) {
-    console.log(`${chalk.green.bgHex("#181c24").bold("[" + moment().format("HH:MM:SS") + "]")}${chalk.bgHex("#181c24").bold.hex("#8c91a7")(" " + task.name + ": ")}`);
-  }
-  return new Promise(resolve => {
-    if (script.lang === "javascript") {
-      requireFromString(script.full, "./fscripts.md");
-      resolve();
-    } else {
-      const cmd = spawn(type, [...script.rest], {
-        stdio: "inherit",
-        env: Object.assign({}, process.env, {
-          FORCE_COLOR: true,
-          PATH: `${path.resolve("node_modules/.bin")}:${process.env.PATH}`,
-          ...script.env
-        })
-      });
-      cmd.on("close", code => {
-        if (code === 0) {
-          resolve();
+import { fireHook } from "../plugins/hooks.js";
+
+export default async ({ script, task, type = script.type }, quiet = false) => {
+    if (!quiet) {
+        console.log(
+            `${chalk.green
+                .bgHex("#181c24")
+                .bold("[" + moment().format("HH:MM:SS") + "]")}${chalk
+                .bgHex("#181c24")
+                .bold.hex("#8c91a7")(" " + task.name + ": ")}`
+        );
+    }
+    const start = Date.now();
+    return new Promise(resolve => {
+        if (script.lang === "javascript") {
+            requireFromString(script.full, "./fscripts.md");
+            fireHook("post-task", { taskName: task.name, duration: Date.now() - start, success: true });
+            resolve();
         } else {
-          console.error(`${chalk.red("ERROR")} ${code} runCli`);
-          resolve();
+            const command = [type, script.full].filter(Boolean).join(" ").trim();
+            const cmd = spawn(command, [], {
+                stdio: "inherit",
+                shell: true,
+                env: Object.assign({}, process.env, {
+                    FORCE_COLOR: true,
+                    PATH: `${path.resolve("node_modules/.bin")}:${process.env.PATH}`,
+                    ...script.env
+                })
+            });
+
+            cmd.on("close", async code => {
+                const duration = Date.now() - start;
+                if (code !== 0) {
+                    console.error(`${chalk.red("ERROR")} ${code} runCli`);
+                    await fireHook("task-error", { taskName: task.name, duration, error: new Error(`exit code ${code}`) });
+                } else {
+                    await fireHook("post-task", { taskName: task.name, duration, success: true });
+                }
+                resolve();
+            });
         }
-      });
-      // }
-    }
-  });
-};
+    });
+};

package/dist/lib/running/runParallel.js

@@ -1,65 +1,67 @@
 import runCLICommand from "./runCLICommand.js";
 import chalk from "chalk";
+
 const runParallel = async (tasks, FcScripts) => {
-  const promises = tasks.map(async taskName => {
-    return new Promise(async resolve => {
-      const taskData = FcScripts.allTasks.find(z => z.name === taskName);
-      if (!taskData) {
-        console.error(`${chalk.bold.underline.red("Task not found")}`);
-        resolve();
-      } else {
-        let {
-          script,
-          lang
-        } = taskData;
-        if (lang === "javascript") {
-          // For JavaScript, use the script as-is without parsing
-          await runCLICommand({
-            task: {
-              name: taskName
-            },
-            script: {
-              lang: lang,
-              env: {},
-              type: "node",
-              full: script,
-              rest: []
+    const promises = tasks.map(async taskName => {
+        return new Promise(async resolve => {
+            const taskData = FcScripts.allTasks.find(z => z.name === taskName);
+            if (!taskData) {
+                console.error(`${chalk.bold.underline.red("Task not found")}`);
+                resolve();
+            } else {
+                let { script, lang } = taskData;
+
+                try {
+                    if (lang === "javascript") {
+                        // For JavaScript, use the script as-is without parsing
+                        await runCLICommand({
+                            task: { name: taskName },
+                            script: {
+                                lang: lang,
+                                env: {},
+                                type: "node",
+                                full: script,
+                                rest: []
+                            }
+                        });
+                    } else {
+                        // For bash scripts, parse command and environment variables
+                        let pars = script.split(" ");
+                        let type = pars[0];
+                        let env = {};
+                        if (pars[0].includes("=")) {
+                            let envs = type.split("=");
+                            env[envs[0]] = envs[1];
+                            type = pars[1];
+                            pars.shift();
+                            pars.shift();
+                            script = pars.join(" ");
+                        } else {
+                            pars.shift();
+                            script = pars.join(" ");
+                        }
+
+                        await runCLICommand({
+                            task: { name: taskName },
+                            script: {
+                                lang: lang,
+                                env: env,
+                                type: type,
+                                full: script,
+                                rest: script.split(" ")
+                            }
+                        });
+                    }
+                } catch (error) {
+                    // Silently catch errors to allow other tasks to continue
+                    // Error logging is handled by runCLICommand
+                }
+                resolve();
             }
-          });
-          resolve();
-        } else {
-          // For bash scripts, parse command and environment variables
-          let pars = script.split(" ");
-          let type = pars[0];
-          let env = {};
-          if (pars[0].includes("=")) {
-            let envs = type.split("=");
-            env[envs[0]] = envs[1];
-            type = pars[1];
-            pars.shift();
-            pars.shift();
-            script = pars.join(" ");
-          } else {
-            pars.shift();
-            script = pars.join(" ");
-          }
-          await runCLICommand({
-            task: {
-              name: taskName
-            },
-            script: {
-              lang: lang,
-              env: env,
-              type: type,
-              full: script,
-              rest: script.split(" ")
-            }
-          });
-          resolve();
-        }
-      }
+        });
     });
-  });
-  let results = await Promise.all(promises);
+
+    let results = await Promise.all(promises);
 };
-export default runParallel;
+
+export default runParallel;

package/dist/lib/running/runSequence.js

@@ -1,60 +1,62 @@
 import runCLICommand from "./runCLICommand.js";
 import chalk from "chalk";
+
 const runSequence = async (tasks, FcScripts) => {
-  for (let t in tasks) {
-    let taskName = tasks[t];
-    const taskData = FcScripts.allTasks.find(z => z.name === taskName);
-    if (!taskData) {
-      console.error(`${chalk.bold.underline.red("Task not found")}`);
-    } else {
-      let {
-        script,
-        lang
-      } = taskData;
-      if (lang === "javascript") {
-        // For JavaScript, use the script as-is without parsing
-        await runCLICommand({
-          task: {
-            name: taskName
-          },
-          script: {
-            lang: lang,
-            env: {},
-            type: "node",
-            full: script,
-            rest: []
-          }
-        });
-      } else {
-        // For bash scripts, parse command and environment variables
-        let pars = script.split(" ");
-        let type = pars[0];
-        let env = {};
-        if (pars[0].includes("=")) {
-          let envs = type.split("=");
-          env[envs[0]] = envs[1];
-          type = pars[1];
-          pars.shift();
-          pars.shift();
-          script = pars.join(" ");
+    for (let t in tasks) {
+        let taskName = tasks[t];
+        const taskData = FcScripts.allTasks.find(z => z.name === taskName);
+        if (!taskData) {
+            console.error(`${chalk.bold.underline.red("Task not found")}`);
         } else {
-          pars.shift();
-          script = pars.join(" ");
+            let { script, lang } = taskData;
+
+            try {
+                if (lang === "javascript") {
+                    // For JavaScript, use the script as-is without parsing
+                    await runCLICommand({
+                        task: { name: taskName },
+                        script: {
+                            lang: lang,
+                            env: {},
+                            type: "node",
+                            full: script,
+                            rest: []
+                        }
+                    });
+                } else {
+                    // For bash scripts, parse command and environment variables
+                    let pars = script.split(" ");
+                    let type = pars[0];
+                    let env = {};
+                    if (pars[0].includes("=")) {
+                        let envs = type.split("=");
+                        env[envs[0]] = envs[1];
+                        type = pars[1];
+                        pars.shift();
+                        pars.shift();
+                        script = pars.join(" ");
+                    } else {
+                        pars.shift();
+                        script = pars.join(" ");
+                    }
+
+                    await runCLICommand({
+                        task: { name: taskName },
+                        script: {
+                            lang: lang,
+                            env: env,
+                            type: type,
+                            full: script,
+                            rest: script.split(" ")
+                        }
+                    });
+                }
+            } catch (error) {
+                // Silently catch errors to allow sequential execution to continue
+                // Error logging is handled by runCLICommand
+            }
         }
-        await runCLICommand({
-          task: {
-            name: taskName
-          },
-          script: {
-            lang: lang,
-            env: env,
-            type: type,
-            full: script,
-            rest: script.split(" ")
-          }
-        });
-      }
     }
-  }
 };
-export default runSequence;
+
+export default runSequence;