fscr 5.4.0 → 6.1.1

package/dist/lib/taskList.js

@@ -0,0 +1,93 @@
+import inquirer from "inquirer";
+const separator = "   ~   ";
+import termSize from "term-size";
+import chalk from "chalk";
+const convertBold = e => {
+  let reg = /(\*\*|^\*\*)(?=\S)([\s\S]*?\S)\*\*(?![\*\*\S])/g;
+  let boldMatches = e.match(reg);
+  if (boldMatches !== null) {
+    boldMatches.forEach(m => {
+      e = e.replace(m, chalk.bold.redBright(m.replace(/\*\*/g, ""))); //.underline.bgBlack.whiteBright
+    });
+  }
+  let regunderline = /(_|^_)(?=\S)([\s\S]*?\S)_(?![_\S])/g;
+  let underlineMatches = e.match(regunderline);
+  if (underlineMatches !== null) {
+    underlineMatches.forEach(m => {
+      e = e.replace(m, chalk.underline.greenBright(m.replace(/\_\_/g, ""))); //.underline.bgBlack.whiteBright
+    });
+  }
+  return e;
+};
+const convertBoldArray = arr => {
+  return arr.map(e => {
+    return convertBold(e);
+  });
+};
+const taskList = async (FcScripts, recentTasks) => {
+  return new Promise(resolve => {
+    let choiceCategories = [...recentTasks.map(cat => {
+      return {
+        name: `${chalk.bold.underline.green(cat)}`,
+        value: {
+          type: "task",
+          name: cat
+        }
+      };
+    }), {
+      name: "-------------",
+      value: null
+    }, ...FcScripts.categories.map(cat => {
+      return {
+        name: `${chalk.bold.underline.green(cat.name)} ${separator} ${convertBold(cat.description)}`,
+        value: {
+          type: "category",
+          name: cat.name
+        }
+      };
+    })];
+    const {
+      rows
+    } = termSize();
+    //=> {columns: 143, rows: 24}
+    inquirer.prompt([{
+      type: "list",
+      name: "category",
+      message: "What category do you want to run?",
+      pageSize: rows - 1,
+      choices: choiceCategories
+    }]).then(({
+      category
+    }) => {
+      let sepInd = choiceCategories.indexOf("-------------");
+      let chosenInd = choiceCategories.indexOf(category);
+      if (category === null) {
+        console.log("Can't select divider");
+      } else if (category.type === "task") {
+        let taskToRun = category.name.split(separator)[0].trim();
+        resolve(taskToRun);
+      } else {
+        let categoryName = category.name.split(separator)[0];
+        let catObj = FcScripts.categories.findIndex(e => e.name === category.name);
+        catObj = FcScripts.categories[catObj];
+        let taskNames = Object.keys(catObj.tasks).map(taskName => {
+          let task = catObj.tasks[taskName];
+          return `${taskName} ${task.description ? separator + task.description.replace(/\n/g, " ").trim() : ""}`;
+        });
+        taskNames = convertBoldArray(taskNames);
+        inquirer.prompt([{
+          type: "list",
+          name: "taskToRun",
+          message: "Which task do you want to run",
+          choices: taskNames
+        }]).then(({
+          taskToRun
+        }) => {
+          taskToRun = taskToRun.split(separator)[0].trim();
+          resolve(taskToRun);
+        });
+      }
+    });
+  });
+};
+export default taskList;

package/dist/lib/taskListAutoComplete.js

@@ -0,0 +1,10 @@
+const scriptsDir = process.cwd();
+import path from "path";
+const rootDir = path.join(scriptsDir, "../");
+const separator = "   ~   ";
+import Conf from "conf";
+const config = new Conf();
+export default taskListAutoComplete;
+// (async () => {
+//     await startScripts();
+// })();

package/dist/lib/upgradePackages.js

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+import childProcess from "child_process";
+import chalk from "chalk";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const logError = message => {
+  console.log(chalk.red("[Error]: " + message));
+};
+const logInfo = message => {
+  console.log(chalk.blue("[Start]: " + message));
+};
+const logSuccess = message => {
+  console.log(chalk.green("[Done]: " + message));
+};
+let global = "";
+let packagePath = path.resolve(process.cwd(), "package.json");
+if (!fs.existsSync(packagePath)) {
+  logError("Cannot find package.json file in the current directory");
+  process.exit(1);
+}
+const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+let ignorePkgs = [];
+const upgradePackages = async () => {
+  if (packageJson["fscripts"]) {
+    if (packageJson["fscripts"]["ignore-upgrade"]) {
+      ignorePkgs = packageJson["fscripts"]["ignore-upgrade"];
+    }
+  }
+  let upgraded = {
+    before: {},
+    after: {}
+  };
+  for (let element of ["dependencies", "devDependencies", "peerDependencies"]) {
+    if (packageJson[element]) {
+      const packages = Object.keys(packageJson[element]);
+      let packagesList = packages.filter(pkk => !ignorePkgs.includes(pkk)).map(pkk => {
+        upgraded["before"][pkk] = packageJson[element][pkk];
+        return pkk + "@latest";
+      }).join(" ");
+      let command = `yarn add ${packagesList}`;
+      try {
+        // logInfo(command);
+        childProcess.execSync(command, {
+          stdio: "inherit",
+          env: Object.assign({}, process.env, {
+            FORCE_COLOR: true,
+            PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
+          })
+        });
+        const packageJsonAfter = JSON.parse(fs.readFileSync(packagePath));
+        const packagesAfter = Object.keys(packageJsonAfter[element]);
+        let packagesListAfter = packagesAfter.filter(pkk => !ignorePkgs.includes(pkk)).map(pkk => {
+          upgraded["after"][pkk] = packageJsonAfter[element][pkk];
+          return upgraded["before"][pkk] !== upgraded["after"][pkk] ? `Updated: ${pkk} from: ${upgraded["before"][pkk]} | to: ${upgraded["after"][pkk]}\n` : ``;
+        }).join("");
+        logSuccess(packagesListAfter);
+      } catch (e) {
+        logError(`${command} - ${e}`);
+      }
+    }
+  }
+};
+export default upgradePackages;

package/dist/lib/utils/clear.js

@@ -0,0 +1,18 @@
+/**
+ * Clears console
+ * @param opts pass true to fully clear
+ */
+export default function clear(opts) {
+  if (typeof opts === "boolean") {
+    opts = {
+      fullClear: opts
+    };
+  }
+  opts = opts || {};
+  opts.fullClear = opts.hasOwnProperty("fullClear") ? opts.fullClear : true;
+  if (opts.fullClear === true) {
+    process.stdout.write("\x1b[2J");
+  }
+  process.stdout.write("\x1b[0f");
+}
+;

package/dist/lib/utils/console.js

@@ -0,0 +1,33 @@
+import { timestamp } from "./helpers.js";
+import chalk from "chalk";
+const d = timestamp();
+const colors = {
+  Reset: "\x1b[0m",
+  Red: "\x1b[31m",
+  Green: "\x1b[32m",
+  Yellow: "\x1b[33m"
+};
+const infoLog = console.info;
+const logLog = console.log;
+const warnLog = console.warn;
+const errorLog = console.error;
+console.log = function (args) {
+  const copyArgs = Array.prototype.slice.call(arguments);
+  copyArgs.unshift(`${chalk.gray(d)} ${chalk.gray.bold("[LOG]")}️`);
+  infoLog.apply(null, copyArgs);
+};
+console.info = function (args) {
+  const copyArgs = Array.prototype.slice.call(arguments);
+  copyArgs.unshift(`${chalk.gray(d)} ${chalk.blue.bold("i [INFO]")}️`);
+  infoLog.apply(null, copyArgs);
+};
+console.warn = function (args) {
+  const copyArgs = Array.prototype.slice.call(arguments);
+  copyArgs.unshift(`${chalk.gray(d)} ${chalk.yellow.bold("⚠ [WARN]")}️`);
+  warnLog.apply(null, copyArgs);
+};
+console.error = function (args) {
+  const copyArgs = Array.prototype.slice.call(arguments);
+  copyArgs.unshift(`${chalk.gray(d)} ${chalk.red.bold("× [ERROR]")}️`);
+  warnLog.apply(null, copyArgs);
+};

package/dist/lib/utils/encryption.js

@@ -0,0 +1,18 @@
+import crypto from "crypto";
+const algorithm = "aes-192-cbc";
+const iv = Buffer.alloc(16, 0); // Initialization vector.
+const encrypt = (toEncrypt, password) => {
+  const key = crypto.scryptSync(password, "salt", 24);
+  const cipher = crypto.createCipheriv(algorithm, key, iv);
+  let encrypted = cipher.update(toEncrypt, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  return encrypted;
+};
+const decrypt = (toDecrypt, password) => {
+  const key = crypto.scryptSync(password, "salt", 24);
+  const decipher = crypto.createDecipheriv(algorithm, key, iv);
+  let decrypted = decipher.update(toDecrypt, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+};
+export { decrypt, encrypt };

package/dist/lib/utils/helpers.js

@@ -0,0 +1,228 @@
+import fs from "fs-extra";
+import chalk from "chalk";
+import boxen from "boxen";
+const ONE_SIXTH = 1 / 6;
+const ONE_THIRD = 1 / 3;
+const TWO_THIRDS = 2 / 3;
+const utils = {};
+
+/**
+ * Output json file
+ * @param f - file name with directory
+ * @return {boolean}
+ * @example
+ const file = "/tmp/this/path/does/not/exist/file.json";
+ removeFile(file);
+ */
+utils.emptyDir = async f => {
+  try {
+    await fs.emptyDir(f);
+    // console.log(`${chalk.green.underline("Directory")} ${chalk.bold(f)} emptied!`);
+  } catch (err) {
+    console.error(err);
+  }
+};
+const desiredMode = 0o2775;
+const defaultOptions = {
+  mode: desiredMode
+};
+utils.ensureDir = async (directory, options = defaultOptions) => {
+  try {
+    await fs.ensureDir(directory, options);
+  } catch (err) {
+    console.error(err);
+  }
+};
+utils.ensureFile = async f => {
+  try {
+    await fs.ensureFile(f);
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+/**
+ * Ensure path exists with dirs
+ * @param f the file path
+ * @return {boolean}
+ * @example
+ const file = ".fsr/config.json";
+ pathExists(file);
+ */
+utils.pathExists = async f => {
+  const exists = await fs.pathExists(f);
+  return exists;
+};
+
+/**
+ * Read json file
+ * @param f - file name with directory
+ * @return {Promise<void>}
+ * @example
+ const file = "/tmp/this/path/does/not/exist/file.json";
+ outputJson(file);
+ */
+utils.readJson = async f => {
+  try {
+    const packageObj = await fs.readJson(f);
+    // console.log(`${chalk.green.underline("File")} ${chalk.bold(f)} read!`);
+    return packageObj;
+  } catch (err) {
+    console.error(err);
+    return {};
+  }
+};
+utils.readFile = async f => {
+  try {
+    let fl = await fs.readFileSync(f, "utf8");
+    return fl;
+  } catch (err) {
+    console.error(err);
+    return {};
+  }
+};
+utils.removeFile = async f => {
+  try {
+    // console.log(`${chalk.green.underline("File")} ${chalk.bold(f)} removed!`);
+    return await fs.remove(f);
+  } catch (err) {
+    console.error(`File ${f} NOT REMOVED! ${err}`);
+    return false;
+  }
+};
+
+/**
+ * Write file
+ * @param f - file name with directory
+ * @param contents - text inside the file
+ * @return {Promise<void>}
+ * @example
+ const file = "/tmp/this/path/does/not/exist/file.json";
+ writeFile(file);
+ */
+utils.writeFile = async (f, contents = "") => {
+  try {
+    return fs.writeFileSync(f, contents, "utf-8");
+    // console.log(`${chalk.green.underline("File")} ${chalk.bold(f)} written!`);
+  } catch (err) {
+    console.error(err);
+  }
+};
+utils.writeJson = async (f, json = {}) => {
+  try {
+    await fs.writeJson(f, json);
+    // console.log(`${chalk.green.underline("File")} ${chalk.bold(f)} written!`);
+  } catch (err) {
+    console.error(err);
+  }
+};
+utils.chainAsync = fns => {
+  let curr = 0;
+  const last = fns[fns.length - 1];
+  const next = () => {
+    const fn = fns[curr++];
+    fn === last ? fn() : fn(next);
+  };
+  next();
+};
+utils.appendToFile = async (f, contents = "") => {
+  try {
+    await fs.appendFileSync(f, contents);
+  } catch (err) {
+    console.error(err);
+  }
+};
+utils.boxInform = async (msg, secondary = "", padding = 0, margin = {
+  left: 2,
+  top: 0,
+  bottom: 0,
+  right: 0
+}) => {
+  console.log(boxen(chalk.hex("#717877")(msg) + "\n" + chalk.bold.underline.hex("#438b34")(secondary) + chalk.hex("#717877")(" "), {
+    padding,
+    margin,
+    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",
+    align: "center" //,
+  }));
+};
+const hue2rgb = (p, q, t) => {
+  if (t < 0) {
+    t += 1;
+  }
+  if (t > 1) {
+    t -= 1;
+  }
+  if (t < ONE_SIXTH) {
+    return p + (q - p) * 6 * t;
+  }
+  if (t < 0.5) {
+    return q;
+  }
+  if (t < TWO_THIRDS) {
+    return p + (q - p) * (TWO_THIRDS - t) * 6;
+  }
+  return p;
+};
+const hsl2rgb = (h, s, l) => {
+  if (s === 0) {
+    return new Array(3).fill(l);
+  }
+  const q = l < 0.5 ? l * s + l : l + s - l * s;
+  const p = 2 * l - q;
+  return [hue2rgb(p, q, h + ONE_THIRD), hue2rgb(p, q, h), hue2rgb(p, q, h - ONE_THIRD)];
+};
+utils.rainbowGradient = (len, saturation = 1, lightness = 0.5) => {
+  const gradient = [];
+  for (let x = 0; x < len; x++) {
+    gradient.push(hsl2rgb(x / len, saturation, lightness).map(c => Math.round(c * 255)));
+  }
+  return gradient;
+};
+
+/**
+ * Return a timestamp with the format "m-d-yy_hh:MM:ss"
+ * @type {Date}
+ */
+utils.timestamp = () => {
+  // Create a date object with the current time
+  let now = new Date();
+
+  // Create an array with the current hour, minute and second
+  let time = [now.getHours(), now.getMinutes(), now.getSeconds()];
+  time = time.map(e => {
+    if (e < 10) {
+      return (e + "").padStart(2, "0");
+    } else {
+      return e;
+    }
+  });
+  // Return the formatted string
+  return time.join(":");
+};
+
+// utils.emptyDir = async () => {};
+export default utils;
+export const {
+  emptyDir,
+  ensureDir,
+  ensureFile,
+  pathExists,
+  readJson,
+  readFile,
+  removeFile,
+  writeFile,
+  writeJson,
+  chainAsync,
+  appendToFile,
+  boxInform,
+  rainbowGradient,
+  timestamp
+} = utils;

package/dist/lib/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./helpers.js";
+export { default as clear } from "./clear.js";

package/dist/lib/utils/prompt.js

@@ -0,0 +1,34 @@
+import enquirerPkg from "enquirer";
+const {
+  prompt
+} = enquirerPkg;
+import chalk from "chalk";
+const promptQuestion = async (extended = {}, message = `name it:`) => {
+  if (extended.type === "list") {
+    extended.type = "select";
+  }
+  if (extended.message) {
+    message = extended.message;
+  }
+  if (extended.choices && extended.choices[0].value) {
+    extended.choices = extended.choices.map(e => {
+      return {
+        message: e.name,
+        value: e.value
+      };
+    });
+  }
+  if (extended.pageSize) {
+    extended.limit = extended.pageSize;
+  }
+  const {
+    answer
+  } = await prompt({
+    type: "input",
+    message: `${chalk.green.bold.underline(message)}`,
+    name: `answer`,
+    ...extended
+  });
+  return answer;
+};
+export default promptQuestion;

package/package.json

@@ -1,16 +1,19 @@
 {
     "name": "fscr",
-    "version": "5.4.0",
+    "version": "6.1.1",
     "description": "Runs the fscripts.md file",
+    "type": "module",
     "main": "./dist/index.js",
     "scripts": {
         "prebuild": "rimraf dist/*",
         "build": "run-p build:index build:lib",
         "build:index": "babel index.js --ignore 'node_modules' --out-file dist/index.js",
         "build:lib": "babel lib --ignore 'node_modules' --out-dir dist/lib --copy-files",
+        "build:combined": "rimraf dist && run-p build:index build:lib && echo '✅ Distributable build complete in dist/'",
         "fsr": "node dist/index.js",
         "release": "run-s release:bump release:clean release:build release:publish",
-        "release:build": "parcel build index.js --target node --no-cache --no-source-maps",
+        "old:release:build": "parcel build index.js --target node --no-cache --no-source-maps",
+        "release:build": "run-p build:index build:lib",
         "release:bump": "yarn fsr bump",
         "release:clean": "rimraf dist",
         "release:combined": "np --any-branch",
@@ -43,13 +46,15 @@
     "license": "MIT",
     "author": "Angel Grablev <agrublev@gmail.com>",
     "files": [
-        "dist"
+        "dist",
+        "bin"
     ],
     "bin": {
         "fscr": "./bin",
         "fsr": "./bin"
     },
     "dependencies": {
+        "@babel/runtime": "^7.9.2",
         "better-md-2-json": "^1.0.6",
         "boxen": "^4.2.0",
         "chalk": "^3.0.0",
@@ -111,14 +116,12 @@
         "@babel/preset-react": "^7.9.1",
         "@babel/preset-typescript": "^7.9.0",
         "@babel/register": "^7.9.0",
-        "@babel/runtime": "^7.9.2",
         "babel-plugin-add-react-displayname": "^0.0.5",
         "babel-plugin-dynamic-import-node": "^2.3.0",
         "babel-plugin-module-resolver": "^4.0.0",
         "babel-plugin-syntax-dynamic-import": "^6.18.0",
         "babel-plugin-transform-react-remove-prop-types": "^0.4.24",
         "babel-plugin-transform-remove-console": "^6.9.4",
-        "eslint-plugin-prettier": "^3.1.2",
         "fancy-log": "^1.3.3",
         "fkill-cli": "^6.0.1",
         "google-auth-library": "^6.0.0",
@@ -140,14 +143,12 @@
         "parcel-bundler": "^1.12.5",
         "parcel-plugin-copy": "^1.0.2",
         "prepend-file": "^1.3.1",
-        "prettier": "^2.0.1",
         "pretty-console-colors": "^1.1.1",
         "pull-request": "^3.0.0",
         "react": "^16.13.1",
         "remarkable": "^2.0.0",
         "rexrex": "^1.3.0",
         "rimraf": "^3.0.2",
-        "semantic-release": "^17.0.4",
         "term-size": "^2.2.0",
         "terminal-tree": "^0.0.3",
         "underscore.string": "^3.3.5",
@@ -155,5 +156,6 @@
     },
     "peerDependencies": {
         "chalk": "^2.4.2"
-    }
+    },
+    "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }