fscr 5.4.0 → 6.1.1

package/dist/lib/release/releasenotes.js

@@ -0,0 +1,158 @@
+// let modifiedGitFiles = await ggg({ diffFilter: "M", showStatus: false, showCommitted: false });
+// modifiedGitFiles = modifiedGitFiles.unCommittedFiles;
+// console.log("MODDED", modifiedGitFiles);
+// const res = await sgf();
+import { writeFile } from "../utils/helpers.js";
+import path from "path";
+import fs from "fs";
+import releaseNotes from "git-release-notes";
+import inquirer from "inquirer";
+import jclrz from "json-colorz";
+import git from "git-state";
+import chalk from "chalk";
+import ggg from "git-changed-files";
+import tree from "./tree.js";
+import childProcess from "child_process";
+// const tree = require("terminal-tree");
+
+// jclrz.level.show = true;
+// jclrz.level.spaces = 2;
+// jclrz.level.start = 1;
+// jclrz.level.char = chalk.bold.grey("⌐");
+// jclrz.level.color = "black";
+// for (const ss in syms) {
+//     jclrz.level.char = chalk.bold.grey(syms[ss]);
+// }
+// var toSymbol = String.fromCharCode(10132);
+// const syms = ["⌯", "➢", "⃕", "⌁", "⌐", "━", "═", "⇝"];
+
+const pathToCwd = process.cwd();
+const grouped = (data, filesChanged) => {
+  let output = {};
+  let current;
+  for (const pdata of data) {
+    current = output;
+    for (const segment of pdata.split("/")) {
+      if (segment !== "") {
+        if (!(segment in current)) {
+          current[segment] = {};
+        }
+        current = current[segment];
+      }
+    }
+  }
+  let level = "";
+  const deepClone = obj => {
+    let clone = Object.assign({}, obj);
+    Object.keys(clone).forEach(key => {
+      let findMac = filesChanged.find(z => z.filename === key || z.filename === level + key);
+      if (typeof obj[key] === "object" && Object.keys(obj[key]).length) {
+        level += key + "/";
+        clone[key] = deepClone(obj[key]);
+      } else if (findMac) {
+        let stat = findMac.status === undefined ? "Deleted" : findMac.status;
+        console.info("-- Console STATUS", findMac.status, stat, key);
+        stat = stat.replace(/\x1B[[(?);]{0,2}(;?\d)*./g, "");
+        clone[key] = stat;
+      } else {
+        clone[key] = "";
+      }
+      return clone[key];
+    });
+    return Array.isArray(obj) ? (clone.length = obj.length) && Array.from(clone) : clone;
+  };
+  output = deepClone(output);
+  console.info(tree(output, {
+    symbol: true,
+    highlight: true,
+    padding: 1,
+    colors: {
+      string: "black",
+      number: "red",
+      boolean: "red",
+      infinity: "red",
+      nan: "red",
+      null: "cyan",
+      undefined: "gray",
+      regexp: "green",
+      key: "black",
+      object: "grey",
+      array: "red"
+    }
+  }));
+
+  // jclrz(output);
+  //
+  return output;
+};
+import sgfPkg from "staged-git-files";
+const sgf = sgfPkg.default || sgfPkg;
+(async () => {
+  const howManyCommitsBack = await new Promise(resolve => {
+    inquirer.prompt([{
+      type: "input",
+      message: "How many commits do you want to compare in the past?",
+      default: 5,
+      name: "howMany"
+    }]).then(async ({
+      howMany
+    }) => {
+      resolve(howMany);
+    });
+  });
+  const results = await sgf();
+  let updatedFiles = await ggg({
+    diffFilter: "ACDMRTUXB",
+    showStatus: true,
+    showCommitted: false
+  });
+  updatedFiles = [...updatedFiles.unCommittedFiles, ...results];
+  let z = ""; // grouped(updatedFiles.map(e => e.filename).sort(), updatedFiles);
+  try {
+    z = childProcess.execSync(`git log -${howManyCommitsBack} --oneline | nl -v0 | sed 's/^ \\+/&HEAD~/'`, {
+      env: Object.assign({}, process.env)
+    }).toString();
+    // console.info("--- INFO z", z);
+  } catch (e) {}
+  z = z.split("\n").slice(-2)[0].split("\t").slice(-2)[1].split(" ")[0];
+  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);
+      });
+    });
+  });
+  console.info("-- Console FROM", z, "TO", last);
+  const OPTIONS = {
+    branch: "Development"
+  };
+  const RANGE = `${z}..${last}`;
+  const TEMPLATE = "markdown";
+  const changelog = await releaseNotes(OPTIONS, RANGE, TEMPLATE);
+  console.log(`Changelog between ${RANGE}\n\n${changelog}`);
+  // await fs.writeFileSync(path.resolve(process.cwd(), "release.md"), changelog, "utf-8");
+})();
+//
+
+// git.check(path, function(err, result) {
+//     if (err) throw err;
+//     console.log(result); // => { branch: 'master',
+//     //      ahead: 0,
+//     //      dirty: 9,
+//     //      untracked: 1,
+//     //      stashes: 0 }
+// });
+
+//     console.info(
+//         '-- Console path.resolve(process.cwd(), "release.md")',
+//         path.resolve(process.cwd(), "release.md")
+//     );
+//
+
+//
+//     // .catch(ex => {
+//     // console.error(ex);
+//     // process.exit(1);
+//     // resolve();

package/dist/lib/release/seeChangedFiles.js

@@ -0,0 +1,89 @@
+// let modifiedGitFiles = await ggg({ diffFilter: "M", showStatus: false, showCommitted: false });
+// modifiedGitFiles = modifiedGitFiles.unCommittedFiles;
+// console.log("MODDED", modifiedGitFiles);
+// const res = await sgf();
+import chalk from "chalk";
+import ggg from "git-changed-files";
+import tree from "./tree.js";
+// const tree = require("terminal-tree");
+
+// jclrz.level.show = true;
+// jclrz.level.spaces = 2;
+// jclrz.level.start = 1;
+// jclrz.level.char = chalk.bold.grey("⌐");
+// jclrz.level.color = "black";
+// for (const ss in syms) {
+//     jclrz.level.char = chalk.bold.grey(syms[ss]);
+// }
+// var toSymbol = String.fromCharCode(10132);
+// const syms = ["⌯", "➢", "⃕", "⌁", "⌐", "━", "═", "⇝"];
+
+const grouped = (data, filesChanged) => {
+  let output = {};
+  let current;
+  for (const pdata of data) {
+    current = output;
+    for (const segment of pdata.split("/")) {
+      if (segment !== "") {
+        if (!(segment in current)) {
+          current[segment] = {};
+        }
+        current = current[segment];
+      }
+    }
+  }
+  let level = "";
+  const deepClone = obj => {
+    let clone = Object.assign({}, obj);
+    Object.keys(clone).forEach(key => {
+      let findMac = filesChanged.find(z => z.filename === key || z.filename === level + key);
+      if (typeof obj[key] === "object" && Object.keys(obj[key]).length) {
+        level += key + "/";
+        clone[key] = deepClone(obj[key]);
+      } else if (findMac) {
+        let stat = findMac.status === undefined ? "Deleted" : findMac.status;
+        stat = stat.replace(/\x1B[[(?);]{0,2}(;?\d)*./g, "");
+        clone[key] = stat;
+      } else {
+        clone[key] = "";
+      }
+      return clone[key];
+    });
+    return Array.isArray(obj) ? (clone.length = obj.length) && Array.from(clone) : clone;
+  };
+  output = deepClone(output);
+
+  // jclrz(output);
+  //
+  return output;
+};
+import sgfPkg from "staged-git-files";
+const sgf = sgfPkg.default || sgfPkg;
+const seeChangedFiles = async () => {
+  const results = await sgf();
+  let updatedFiles = await ggg({
+    diffFilter: "ACDMRTUXB",
+    showStatus: true,
+    showCommitted: false
+  });
+  updatedFiles = [...updatedFiles.unCommittedFiles, ...results];
+  console.log(tree(grouped(updatedFiles.map(e => e.filename).sort(), updatedFiles), {
+    symbol: true,
+    highlight: true,
+    padding: 1,
+    colors: {
+      string: "black",
+      number: "red",
+      boolean: "red",
+      infinity: "red",
+      nan: "red",
+      null: "cyan",
+      undefined: "gray",
+      regexp: "green",
+      key: "black",
+      object: "grey",
+      array: "red"
+    }
+  }));
+};
+export default seeChangedFiles;

package/dist/lib/release/sort.js

@@ -0,0 +1,136 @@
+import sortObjectKeys from "sort-object-keys";
+import detectIndentPkg from "detect-indent";
+const detectIndent = detectIndentPkg.default || detectIndentPkg;
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const sortOrder = ["name", "version", "description", "keywords", "sideEffects", "main", "umd:main", "unpkg", "module", "workspaces", "scripts", "betterScripts", "fscripts", "source", "jsnext:main", "browser", "homepage", "bugs", "repository", "private", "license", "author", "contributors", "files", "types", "typings", "style", "example", "examplestyle", "assets", "bin", "man", "directories", "husky", "pre-commit", "commitlint", "lint-staged", "config", "nodemonConfig", "browserify", "babel", "browserslist", "xo", "prettier", "eslintConfig", "eslintIgnore", "stylelint", "jest", "dependencies", "devDependencies", "peerDependencies", "bundledDependencies", "bundleDependencies", "optionalDependencies", "flat", "resolutions", "engines", "engineStrict", "os", "cpu", "preferGlobal", "publishConfig"];
+// See https://docs.npmjs.com/misc/scripts
+const defaultNpmScripts = ["install", "pack", "prepare", "publish", "restart", "shrinkwrap", "start", "stop", "test", "uninstall", "version"];
+function sortPackageJson(packageJson, options = {}) {
+  const determinedSortOrder = options.sortOrder || sortOrder;
+  let wasString = false;
+  let hasWindowsNewlines = false;
+  let endCharacters = "";
+  let indentLevel = 2;
+  if (typeof packageJson === "string") {
+    wasString = true;
+    indentLevel = detectIndent(packageJson).indent;
+    if (packageJson.substr(-1) === "\n") {
+      endCharacters = "\n";
+    }
+    const newlineMatch = packageJson.match(/(\r?\n)/);
+    hasWindowsNewlines = (newlineMatch && newlineMatch[0]) === "\r\n";
+    packageJson = JSON.parse(packageJson);
+  }
+  const prefixedScriptRegex = /^(pre|post)(.)/;
+  const prefixableScripts = defaultNpmScripts.slice();
+  if (typeof packageJson.scripts === "object") {
+    Object.keys(packageJson.scripts).forEach(script => {
+      const prefixOmitted = script.replace(prefixedScriptRegex, "$2");
+      if (packageJson.scripts[prefixOmitted] && !prefixableScripts.includes(prefixOmitted)) {
+        prefixableScripts.push(prefixOmitted);
+      }
+    });
+  }
+  function sortSubKey(key, sortList, unique) {
+    if (Array.isArray(packageJson[key])) {
+      packageJson[key] = packageJson[key].sort();
+      if (unique) {
+        packageJson[key] = array_unique(packageJson[key]);
+      }
+      return;
+    }
+    if (typeof packageJson[key] === "object") {
+      packageJson[key] = sortObjectKeys(packageJson[key], sortList);
+    }
+  }
+  function toSortKey(script) {
+    const prefixOmitted = script.replace(prefixedScriptRegex, "$2");
+    if (prefixableScripts.includes(prefixOmitted)) {
+      return prefixOmitted;
+    }
+    return script;
+  }
+  /*             b
+   *       pre | * | post
+   *   pre  0  | - |  -
+   * a  *   +  | 0 |  -
+   *   post +  | + |  0
+   */
+  function compareScriptKeys(a, b) {
+    if (a === b) return 0;
+    const aScript = toSortKey(a);
+    const bScript = toSortKey(b);
+    if (aScript === bScript) {
+      // pre* is always smaller; post* is always bigger
+      // Covers: pre* vs. *; pre* vs. post*; * vs. post*
+      if (a === `pre${aScript}` || b === `post${bScript}`) return -1;
+      // The rest is bigger: * vs. *pre; *post vs. *pre; *post vs. *
+      return 1;
+    }
+    return aScript < bScript ? -1 : 1;
+  }
+  function array_unique(array) {
+    return array.filter((el, index, arr) => index == arr.indexOf(el));
+  }
+  sortSubKey("keywords", null, true);
+  sortSubKey("homepage");
+  sortSubKey("bugs", ["url", "email"]);
+  sortSubKey("license", ["type", "url"]);
+  sortSubKey("author", ["name", "email", "url"]);
+  sortSubKey("bin");
+  sortSubKey("man");
+  sortSubKey("directories", ["lib", "bin", "man", "doc", "example"]);
+  sortSubKey("repository", ["type", "url"]);
+  sortSubKey("scripts", compareScriptKeys);
+  sortSubKey("betterScripts", compareScriptKeys);
+  sortSubKey("commitlint");
+  sortSubKey("lint-staged");
+  sortSubKey("config");
+  sortSubKey("nodemonConfig");
+  sortSubKey("browserify");
+  sortSubKey("babel");
+  sortSubKey("eslintConfig");
+  sortSubKey("jest");
+  sortSubKey("xo");
+  sortSubKey("prettier");
+  sortSubKey("dependencies");
+  sortSubKey("devDependencies");
+  sortSubKey("peerDependencies");
+  sortSubKey("bundledDependencies");
+  sortSubKey("bundleDependencies");
+  sortSubKey("optionalDependencies");
+  sortSubKey("resolutions");
+  sortSubKey("engines");
+  sortSubKey("engineStrict");
+  sortSubKey("os");
+  sortSubKey("cpu");
+  sortSubKey("preferGlobal");
+  sortSubKey("private");
+  sortSubKey("publishConfig");
+  packageJson = sortObjectKeys(packageJson, determinedSortOrder);
+  if (wasString) {
+    let result = JSON.stringify(packageJson, null, indentLevel) + endCharacters;
+    if (hasWindowsNewlines) {
+      result = result.replace(/\n/g, "\r\n");
+    }
+    return result;
+  }
+  return packageJson;
+}
+export default sortPackageJson;
+export { sortPackageJson, sortOrder };
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const filesToProcess = process.argv[2] ? process.argv.slice(2) : [`${process.cwd()}/package.json`];
+  filesToProcess.forEach(filePath => {
+    const packageJson = fs.readFileSync(filePath, "utf8");
+    const sorted = sortPackageJson(packageJson);
+    if (sorted !== packageJson) {
+      fs.writeFileSync(filePath, sorted, "utf8");
+      console.log(`${filePath} is sorted!`);
+    }
+  });
+}

package/dist/lib/release/tree.js

@@ -0,0 +1,163 @@
+import chalk from "chalk";
+function isFunction(f) {
+  return Object.prototype.toString.call(f) === "[object Function]";
+}
+function isRegExp(r) {
+  return r instanceof RegExp;
+}
+function isObject(o) {
+  return !Array.isArray(o) && !isFunction(o) && !isRegExp(o) && o === new Object(o);
+}
+let reColorName = /^(black|red|green|yellow|blue|magenta|cyan|white|gray)$/;
+function coloring(str, color, type) {
+  str = str + "";
+  if (typeof color === "function") {
+    return color(str);
+  } else if (reColorName.test(color)) {
+    if (type === "string") {
+      if (str === "Modified") {
+        return chalk.green(str);
+      } else if (str === "Deleted") {
+        return chalk.red(str);
+      } else {
+        return chalk.blue(str);
+      }
+    } else {
+      return chalk[color].bold.underline.white(str); //
+    }
+  } else {
+    return str;
+  }
+}
+let defaultColors = {
+  string: "yellow",
+  number: "red",
+  boolean: "blue",
+  infinity: "red",
+  nan: "cyan",
+  null: "cyan",
+  undefined: "gray",
+  regexp: "green",
+  key: "magenta",
+  object: "white",
+  array: "white"
+};
+export default function (json, options) {
+  options = options || {};
+  if (options.symbol === undefined) {
+    options.symbol = true;
+  }
+  options.padding = options.padding || 0;
+  options.markdown = options.markdown || false;
+  options.highlight = options.highlight || false;
+  options.colors = options.colors || {};
+  Object.keys(defaultColors).forEach(function (key) {
+    options.colors[key] = options.colors[key] || defaultColors[key];
+  });
+  let output = "";
+  let tree = function (o, depth, index, isLast, inArray, type) {
+    index = [].concat(index || []);
+    depth = depth || 0;
+    index[depth] = 0;
+    if (Array.isArray(o)) {
+      if (inArray) {
+        if (options.symbol) {
+          tree("[]", depth, index, isLast, 0, "array");
+          index[depth] = isLast ? 0 : 1;
+        } else {
+          depth--;
+        }
+      }
+      for (let i = 0, l = o.length; i < l; i++) {
+        tree(o[i], depth + 1, index, i === l - 1, 1);
+      }
+    } else if (isObject(o)) {
+      let keys = Object.keys(o);
+      if (inArray) {
+        // if (options.symbol) {
+        //     tree("", depth, index, isLast, 0, "object");
+        index[depth] = isLast ? 0 : 1;
+        depth++;
+        // }
+      }
+      for (let i = 0, l = keys.length; i < l; i++) {
+        let lastFlg = inArray && !isLast && !options.symbol ? false : i === l - 1;
+        tree(keys[i], depth, index, lastFlg, 0, "key");
+        index[depth] = lastFlg ? 0 : 1;
+        tree(o[keys[i]], depth + 1, index, 1, 1);
+      }
+    } else {
+      index[depth] = isLast ? 3 : 2;
+      if (isFunction(o)) {
+        o = "Function";
+        type = "function";
+      }
+      if (options.markdown) {
+        output += markdownList(depth) + o + "\n";
+      } else {
+        output += format(index) + highlight(o, type) + "\n";
+      }
+    }
+  };
+  let format = function (index) {
+    let s = "";
+    let p = new Array(options.padding + 1).join(" ");
+    for (let i = 0, l = index.length; i < l; i++) {
+      switch (index[i]) {
+        case 1:
+          s += chalk.grey("┃");
+          break;
+        case 2:
+          s += chalk.grey("┣ ");
+          break;
+        case 3:
+          s += chalk.grey("┗");
+          break;
+        default:
+          s += chalk.grey("⌐");
+      }
+      if (i < l - 1) {
+        s += chalk.grey(p);
+      }
+    }
+    return s;
+  };
+  let markdownList = function (depth) {
+    return new Array(depth + 1).join("  ") + "+ ";
+  };
+  let highlight = function (data, type) {
+    let hi;
+    if (!options.highlight) {
+      return data;
+    }
+    if (type === "key") {
+      hi = "key";
+    } else if (type === "array") {
+      hi = "array";
+    } else if (type === "object") {
+      hi = "object";
+    } else if (data !== data) {
+      hi = "nan";
+    } else if (data === Infinity) {
+      hi = "infinity";
+    } else if (typeof data === "string") {
+      hi = "string";
+    } else if (typeof data === "number") {
+      hi = "number";
+    } else if (isRegExp(data)) {
+      hi = "regexp";
+    } else if (typeof data === "boolean") {
+      hi = "boolean";
+    } else if (data === null) {
+      hi = "null";
+    } else if (data === void 0) {
+      hi = "undefined";
+    } else {
+      return data;
+    }
+    return coloring(data, options.colors[hi], hi);
+  };
+  tree(json);
+  return output;
+}
+;

package/dist/lib/release/validateNotDev.js

@@ -0,0 +1,63 @@
+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 { 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);
+  //         });
+  //     });
+  // });
+
+  // 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();
+    });
+  });
+}
+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;