fscr 5.4.1 → 6.1.2

package/dist/lib/encryption/decryptConfig.js

@@ -0,0 +1,81 @@
+const encrypt = require("./encryption");
+(async () => {
+  await encrypt.init();
+})();
+const inquirer = require("inquirer");
+const path = require("path");
+const spawn = require("cross-spawn");
+const argv = require("yargs").argv;
+const clipboardy = require("clipboardy");
+const chalk = require("chalk");
+const cgf = require("changed-git-files");
+const projectDir = process.cwd();
+const packagePath = path.join(projectDir, "./");
+(async () => {
+  if (argv.interactive) {
+    inquirer.prompt({
+      type: "list",
+      name: "typeInc",
+      message: "Type on increment",
+      choices: ["patch", "minor", "major", "semver"],
+      default: "patch"
+    }).then(async ({
+      typeInc
+    }) => {
+      // spawn.sync("yarn", ["start", ...process.argv.slice(2)], {
+      // 	stdio: "inherit",
+      // 	env: Object.assign({}, process.env, {
+      // 		PATH: `${path.resolve("node_modules/.bin")}:${process.env.PATH}`
+      // 	})
+      // });
+      let commitMsg = await bump(typeInc);
+      await clipboardy.write(commitMsg);
+      console.log(chalk.bold.green(`Commit message copied to clipboard:\n`) + chalk.bgWhite.black(`${commitMsg}`));
+      const packageVersion = require(path.join(packagePath, "package.json")).version;
+      await require("simple-git")().fetch().add("./packages/*").commit(commitMsg).addTag(packageVersion).pushTags().push(["-u", "--set-upstream"]);
+    });
+  }
+  if (argv.package) {
+    await runAsync(`yarn version --cwd=packages/${argv.package} --no-git-tag-version --patch --no-commit-hooks`);
+  }
+})();
+async function message(title) {
+  return new Promise(resolve => {
+    inquirer.prompt({
+      type: `text`,
+      name: `commitMessage`,
+      message: title
+    }).then(({
+      commitMessage
+    }) => {
+      resolve(commitMessage);
+    });
+  });
+}
+async function bump(type = "patch") {
+  let defaultCommitMsg = ``;
+  return new Promise(resolve => {
+    cgf(async function (err, results) {
+      let updatedPackages = [];
+      results.forEach(path => {
+        let segments = path.filename.split("/");
+        if (segments[0] === "packages") {
+          if (!updatedPackages.includes(segments[1])) {
+            updatedPackages.push(segments[1]);
+          }
+        }
+      });
+      await runAsync(`yarn version --no-git-tag-version --${type} --no-commit-hooks`);
+      for (let index = 0; index < updatedPackages.length; index++) {
+        await runAsync(`yarn version --${type} --no-git-tag-version --no-commit-hooks --cwd=packages/${updatedPackages[index]}`);
+        let packVer = require(path.join(packagePath, "./packages/" + updatedPackages[index] + "/package.json")).version;
+        defaultCommitMsg += `  [${updatedPackages[index]}]:${packVer}\n`;
+        let whatsNew = `${"Package: " + chalk.cyan(updatedPackages[index])} -- ${chalk.green("New version: " + packVer)}\n${chalk.bold.underline.cyan("What's changed?")}`;
+        defaultCommitMsg += `    - ${await message(whatsNew)}\n\n`;
+      }
+      const packageVersion = require(path.join(packagePath, "package.json")).version;
+      defaultCommitMsg = `Version:${packageVersion}\n- ${await message("Overall change summary:")}\n\n` + defaultCommitMsg;
+      resolve(defaultCommitMsg);
+    });
+  });
+}

package/dist/lib/encryption/encryption.js

@@ -0,0 +1,135 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { encrypt, decrypt } from "../utils/encryption.js";
+import { appendToFile, ensureFile, writeFile, boxInform, readJson, readFile } from "../utils/helpers.js";
+import path from "path";
+const scriptsDir = process.cwd();
+const rootDir = path.join(scriptsDir, "./");
+const packagePath = path.join(rootDir, "package.json");
+const igPath = path.join(rootDir, ".gitignore");
+const encrypted = {
+  encryptedFiles: []
+};
+
+// prettier-ignore
+encrypted.encrypt = async (pass, encryptedFile, decryptedFile) => {
+  let willEncrypt = true;
+  let sureSure = await ensureFile(encryptedFile);
+  if (sureSure) {
+    console.log(`${chalk.bold.red("FILE ALREADY EXISTS ARE YOU SURE?")}`);
+    willEncrypt = await new Promise(resolve => {
+      inquirer.prompt([{
+        type: "confirm",
+        message: chalk.bold.hex("#38be18")(`Sure? (y/n): `),
+        name: "sure"
+      }]).then(({
+        sure
+      }) => {
+        resolve(sure);
+      });
+    });
+  }
+  if (willEncrypt) {
+    let toEncrypt = await readFile(decryptedFile);
+    const ciphertext = encrypt(toEncrypt, pass);
+    await writeFile(encryptedFile, ciphertext.toString());
+  }
+};
+// prettier-ignore
+encrypted.decrypt = async (pass, encryptedFileLocation, decryptedFileLocation) => {
+  // let encryptedFileLocation = path.join(rootDir,"."+encryptedFile);
+  // let decryptedFileLocation = path.join(rootDir,encryptedFile);
+  let willEncrypt = true;
+  let sureSure = await ensureFile(decryptedFileLocation);
+  if (sureSure) {
+    console.log(`${chalk.bold.red("FILE ALREADY EXISTS ARE YOU SURE?")}`);
+    willEncrypt = await new Promise(resolve => {
+      inquirer.prompt([{
+        type: "confirm",
+        message: chalk.bold.hex("#38be18")(`Sure wanna override file ${decryptedFileLocation}? (y/n): `),
+        name: "sure"
+      }]).then(({
+        sure
+      }) => {
+        resolve(sure);
+      });
+    });
+  }
+  if (willEncrypt) {
+    let toDecrypt = await readFile(encryptedFileLocation);
+    const decryptedData = decrypt(toDecrypt, pass);
+    await writeFile(decryptedFileLocation, decryptedData);
+    console.warn(`${chalk.bold.green.underline("DECRYPTED FILE:")} ${chalk.bold.dim(path.join(scriptsDir, decryptedFileLocation))}`);
+  }
+};
+encrypted.init = async () => {
+  try {
+    let pass = await encrypted.getPass();
+    let toEncrypt = await encrypted.toEncrypt();
+    encrypted.packageJson = await readJson(packagePath);
+    encrypted.ignore = await readFile(igPath);
+    encrypted.ignoredFiles = encrypted.ignore.split("\n");
+    if (encrypted.packageJson.fscripts) {
+      if (encrypted.packageJson.fscripts.encryptedFiles) {
+        encrypted.encryptedFiles = encrypted.packageJson.fscripts.encryptedFiles;
+        let filesToAdd = "\n";
+        for (const e of encrypted.encryptedFiles) {
+          if (encrypted.ignoredFiles.indexOf(e) === -1) {
+            filesToAdd += e + "\n";
+          }
+          let file = e + "";
+          let fileSplit = file.split("/");
+          let name = fileSplit.pop();
+          let encryptedFile = fileSplit.slice();
+          let decryptedFile = fileSplit.slice();
+          encryptedFile.push("." + name);
+          encryptedFile = path.join(rootDir, encryptedFile.join("/"));
+          decryptedFile.push(name);
+          decryptedFile = path.join(rootDir, decryptedFile.join("/"));
+          if (toEncrypt) {
+            await encrypted.encrypted(pass, encryptedFile, decryptedFile);
+          } else {
+            await encrypted.decrypt(pass, encryptedFile, decryptedFile);
+          }
+        }
+        if (filesToAdd.trim().length > 0) {
+          await appendToFile(igPath, filesToAdd + "\n");
+          boxInform(" Added files to .gitignore: ", filesToAdd);
+        }
+      }
+    }
+  } catch (err) {
+    console.error(err);
+  }
+};
+encrypted.getPass = async () => {
+  return await new Promise(resolve => {
+    inquirer.prompt([{
+      type: "password",
+      mask: chalk.underline(" ●"),
+      message: chalk.bold.hex("#38be18")(`Enter a SECRET key (same as pass app) : `),
+      name: "pass"
+    }]).then(({
+      pass
+    }) => {
+      resolve(pass);
+    });
+  });
+};
+encrypted.toEncrypt = async () => {
+  return await new Promise(resolve => {
+    inquirer.prompt([{
+      type: "list",
+      message: chalk.bold.hex("#38be18")("Which direction?"),
+      choices: ["encrypt", "decrypt"],
+      name: "encryptDecrypt"
+    }]).then(async ({
+      encryptDecrypt
+    }) => {
+      resolve(encryptDecrypt === "encrypt");
+    });
+  });
+};
+export default {
+  ...encrypted
+};

package/dist/lib/generateFScripts.js

@@ -0,0 +1,25 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { appendToFile, writeFile, boxInform, readJson, readFile } from "./utils/helpers.js";
+import path from "path";
+const projectDir = process.cwd();
+const packagePath = path.join(projectDir, "package.json");
+const gen = {
+  scripts: []
+};
+let mdfile = `# First category of scripts
+
+Welcome to your new amazing fscripts.md file. It replaces the headaches of npm scripts! But so much more.
+`;
+gen.init = async () => {
+  try {
+    gen.packageJson = await readJson(packagePath);
+    Object.keys(gen.packageJson.scripts).forEach(scriptName => {
+      mdfile += `\n## ${scriptName}\n\n${gen.packageJson.scripts[scriptName]}\n\n\`\`\`bash\n${gen.packageJson.scripts[scriptName]}\n\`\`\`\n\n`;
+    });
+    await writeFile("./sample.fscripts.md", mdfile);
+  } catch (err) {
+    console.error(err);
+  }
+};
+export default gen.init;

package/dist/lib/generateToc.js

@@ -0,0 +1,36 @@
+import path from "path";
+import chalk from "chalk";
+import JoyCon from "joycon";
+import tocPkg from "markdown-toc";
+const toc = tocPkg.default || tocPkg;
+const joyRead = new JoyCon({
+  // Stop reading at parent dir
+  // i.e. Only read file from process.cwd()
+  stopDir: path.dirname(process.cwd())
+});
+import { writeFile } from "./utils/helpers.js";
+// const projectDir = process.cwd();
+
+const generateToc = async () => {
+  const {
+    path: filepath,
+    data
+  } = joyRead.loadSync(["fscripts.md"]);
+  if (!filepath) {
+    console.warn(`${chalk.bold.red("You're missing the fscripts.md file!")}
+${chalk.green("Please run 'fsr generate' to get started!")}`);
+    process.exit(0);
+    return null;
+  } else {
+    console.warn(`${chalk.bold.green("Located fscripts.md file!")}`);
+    let newFile = ``;
+    let tocSplit = data.split("<!-- end toc -->");
+    if (tocSplit.length === 2) {
+      newFile = toc(tocSplit[1]).content + "\n<!-- end toc -->\n\n" + tocSplit[1].trim();
+    } else {
+      newFile = toc(data).content + "\n<!-- end toc -->\n\n" + data.trim();
+    }
+    await writeFile("./fscripts.md", newFile);
+  }
+};
+export default generateToc;

package/dist/lib/generators/generateFScripts.js

@@ -0,0 +1,25 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { appendToFile, writeFile, boxInform, readJson, readFile } from "../utils/helpers.js";
+import path from "path";
+const projectDir = process.cwd();
+const packagePath = path.join(projectDir, "package.json");
+const gen = {
+  scripts: []
+};
+let mdfile = `# First category of scripts
+
+Welcome to your new amazing fscripts.md file. It replaces the headaches of npm scripts! But so much more.
+`;
+gen.init = async () => {
+  try {
+    gen.packageJson = await readJson(packagePath);
+    Object.keys(gen.packageJson.scripts).forEach(scriptName => {
+      mdfile += `\n## ${scriptName}\n\n${gen.packageJson.scripts[scriptName]}\n\n\`\`\`bash\n${gen.packageJson.scripts[scriptName]}\n\`\`\`\n\n`;
+    });
+    await writeFile("./sample.fscripts.md", mdfile);
+  } catch (err) {
+    console.error(err);
+  }
+};
+export default gen.init;

package/dist/lib/generators/generateToc.js

@@ -0,0 +1,38 @@
+import path from "path";
+import chalk from "chalk";
+import JoyCon from "joycon";
+import tocPkg from "markdown-toc";
+const toc = tocPkg.default || tocPkg;
+const joyRead = new JoyCon({
+  // Stop reading at parent dir
+  // i.e. Only read file from process.cwd()
+  stopDir: path.dirname(process.cwd())
+});
+import { writeFile } from "../utils/helpers.js";
+// const projectDir = process.cwd();
+
+const generateToc = async (fileToLoad = "fscripts.md") => {
+  const {
+    path: filepath,
+    data
+  } = joyRead.loadSync([fileToLoad]);
+  if (!filepath) {
+    console.warn(`${chalk.bold.red("You're missing the fscripts.md file!")}
+${chalk.green("Please run 'fsr generate' to get started!")}`);
+    process.exit(0);
+    return null;
+  } else {
+    console.warn(`${chalk.bold.green("Located fscripts.md file!")}`);
+    let newFile = ``;
+    let tocSplit = data.split("<!-- end toc -->");
+    let mdContent = "";
+    if (tocSplit.length === 2) {
+      mdContent = tocSplit[1];
+    } else {
+      mdContent = data;
+    }
+    newFile = toc(mdContent).content + "\n<!-- end toc -->\n\n" + mdContent.trim();
+    await writeFile(fileToLoad, newFile);
+  }
+};
+export default generateToc;

package/dist/lib/generators/index.js

@@ -0,0 +1,2 @@
+export { default as generateToc } from "./generateToc.js";
+export { default as generateFScripts } from "./generateFScripts.js";

package/dist/lib/git/files.js

@@ -0,0 +1,26 @@
+import inquirer from "inquirer";
+import inquirerFuzzyPath from "inquirer-fuzzy-path";
+inquirer.registerPrompt("fuzzypath", inquirerFuzzyPath);
+(async () => {
+  return inquirer.prompt([{
+    type: "fuzzypath",
+    name: "path",
+    excludePath: nodePath => nodePath.startsWith("node_modules") || nodePath.startsWith(".git") || nodePath.startsWith(".idea"),
+    // excludePath :: (String) -> Bool
+    // excludePath to exclude some paths from the file-system scan
+    // itemType: "any",
+    itemType: "directory" | "file",
+    //'any' |  | 'file'
+    // specify the type of nodes to display
+    // default value: 'any'
+    // example: itemType: 'file' - hides directories from the item list
+    // rootPath: "app",
+    // rootPath :: String
+    // Root search directory
+    message: "Select a target directory for your component:",
+    // default: "./",
+    suggestOnly: false
+    // suggestOnly :: Bool
+    // Restrict prompt answer to available choices or use them as suggestions
+  }]);
+})();

package/dist/lib/git/pub.js

@@ -0,0 +1,42 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import boxen from "boxen";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import runTask from "./taskRunner.js";
+import { readJson } from "../utils/helpers.js";
+import simple from "simple-git";
+// pub();
+const newBranch = async name => {
+  await simple().checkoutLocalBranch(name);
+};
+async function pub() {
+  // runTask("sh " + path.join(__dirname, "publish.sh") + " --")
+  // .then(async () => {
+  // })
+  // .catch(e => {
+  //     console.warn("-- Console ERR", e);
+  // });
+}
+import validateNotInDev from "./validateNotDev.js";
+(async () => {
+  await validateNotInDev();
+  await new Promise(resolve => {
+    let pack = readJson(path.resolve(__dirname + "package.json"));
+    inquirer.prompt([{
+      type: "input",
+      message: chalk.bold.hex("#38be18")(`What's new this version ${pack.version}: `),
+      name: "commitmsg"
+    }]).then(async ({
+      commitmsg
+    }) => {
+      simple().add("./*").commit(`VERSION ${pack.version}\n${commitmsg}`).push(["-u"], () => console.log("done")).addTag(`${pack.version}`, () => console.warn("")).pushTags("origin", () => {
+        console.warn("-- Console 3", 3);
+        resolve();
+      });
+      // await require("simple-git")()
+    });
+  });
+})();

package/dist/lib/git/taskRunner.js

@@ -0,0 +1,80 @@
+import moment from "moment-mini";
+const tryPath = process.cwd();
+import chalk from "chalk";
+import prettyMs from "pretty-ms";
+import spawn from "cross-spawn";
+import boxen from "boxen";
+import helpers from "../utils/helpers.js";
+const runTask = async (name, conf = false) => {
+  let output;
+  let startTime = Date.now();
+  let input = name.slice(-1) === "-";
+  let task = {};
+  let tasks = [];
+  if (conf !== false) {
+    conf.set("tasks." + name + ".lastRan", startTime);
+    await conf.updateConfigFile();
+    tasks = conf.get("tasks");
+  }
+  let command = conf === false ? name : tasks[name].file ? "node " + tasks[name].file : tasks[name].script;
+  console.clear();
+  console.log(input ? chalk.hex("#4b5150")(" Running: ") + chalk.bold.underline.hex("#438b34")(name) : boxen(chalk.hex("#717877")(" Running: ") + chalk.bold.underline.hex("#438b34")(name) + chalk.hex("#717877")(" "), {
+    padding: 0,
+    margin: {
+      left: 2,
+      top: 0,
+      bottom: 0,
+      right: 0
+    },
+    borderStyle: {
+      topLeft: chalk.hex("#5a596d")("╔"),
+      topRight: chalk.hex("#5a596d")("╗"),
+      bottomLeft: chalk.hex("#5a596d")("╚"),
+      bottomRight: chalk.hex("#5a596d")("╝"),
+      horizontal: chalk.hex("#5a596d")("═"),
+      vertical: chalk.hex("#5a596d")("║")
+    },
+    //"round",
+    // dimBorder: true,
+    align: "center" //,
+    // float: "center"
+  }));
+  try {
+    let pars = command.split(" ");
+    output = spawn(pars[0], pars.slice(1, pars.length), {
+      cwd: tryPath,
+      env: {
+        ...process.env,
+        ...{
+          FORCE_COLOR: true
+        }
+      },
+      stdio: input ? "inherit" : "pipe"
+    });
+    if (!input) {
+      output.stdout.on("data", code => {
+        code = code + "";
+        console.log(`${chalk.bgHex("#181c24").hex("#8c91a7")(moment().format("HH:MM:SS") + ":")} ${code}`.trim());
+      });
+      output.stderr.on("data", code => {
+        code = code + "";
+        console.log(`${chalk.bgHex("#181c24").hex("#a72e32")(moment().format("HH:MM:SS") + "ERR :")} ${code}`.trim());
+      });
+    }
+    return new Promise((resolve, reject) => {
+      output.on("close", code => {
+        if (code === 0) {
+          let elapsed = Date.now() - startTime;
+          console.log(`${chalk.bold.green("Finished in " + prettyMs(elapsed), code)}`);
+          resolve();
+        } else {
+          // console.log(`${chalk.bold.green("Finished in " + prettyMs(elapsed), code)}`);
+          reject(`task exited with code ${code}`);
+        }
+      });
+    });
+  } catch (error) {
+    console.log(`${chalk.red.bold(error)}`);
+  }
+};
+export default runTask;

package/dist/lib/git/validateNotDev.js

@@ -0,0 +1,71 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import boxen from "boxen";
+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);
+  //         });
+  //     });
+  // });
+
+  try {
+    // logInfo(command);
+    childProcess.execSync(`git -c core.quotepath=false -c log.showSignature=false checkout -b ${name}`, {
+      stdio: "inherit",
+      env: Object.assign({}, process.env, {
+        FORCE_COLOR: true,
+        PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
+      })
+    });
+  } catch (e) {}
+
+  // await simple().checkoutLocalBranch(name);
+  // await simple().checkoutBranch(name, "origin");
+  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();
+    });
+  });
+}
+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();
+    }
+  });
+};
+export default validateNotInDev;