js-dev-tool 1.0.0

package/utils.js

@@ -0,0 +1,643 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 2017 jeffy-g hirotom1107@gmail.com
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+*/
+/// <reference types="./basic-types"/>
+// @ts-check
+
+// NOTE: fs-extra are bit slower.
+const fs = require("fs");
+// const util = require('util');
+const path = require("path");
+
+const lib = require("./common");
+const getExtraArgs = require("tin-args");
+
+const CI = !!process.env.CI;
+const log = (() => {
+  return CI ? () => ({}) : console.log;
+})();
+
+/**
+ * get node version at runtime.
+ *
+ * format must be `v\d+.\d+.\d+`
+ *
+ * ex:
+ * ```
+ * const utils = require("./utils");
+ * const nv = utils.extractVersion();
+ * console.log(nv); // => {major: 10, minor: 9, patch: 0}
+ * ```
+ *
+ * @param {string} versionString default is process.version
+ */
+function extractVersion(versionString = process.version) {
+  const RE_VERSION = /v(\d+).(\d+).(\d+)/;
+  // NOTE: pv is Array.isArray(pv), extend Array
+  let pv = RE_VERSION.exec(versionString);
+  const [major = 0, minor = 0, patch = 0] = pv
+    ? pv
+        .map((value, i) => {
+          return (i > 0 && +value) || void 0;
+        })
+        .slice(1)
+    : [];
+  console.log("result:", major, minor, patch);
+  return { major, minor, patch };
+}
+
+/**
+ * use toLocaleString
+ * @param {any} ymd use simple year month day formant? default `false`
+ *  + should be truthy/falsy value
+ */
+function dateStringForFile(ymd = false) {
+  // return new Date().toLocaleString().replace(/\//g, "-").replace(/:/g, "_").replace(/ /g, "@");
+  return new Date()
+    .toLocaleString(void 0, {
+      year: "2-digit",
+      month: "2-digit",
+      day: "2-digit",
+      hour: ymd ? void 0 : "2-digit",
+      minute: ymd ? void 0 : "2-digit",
+      second: ymd ? void 0 : "2-digit",
+      // DEVNOTE: 191215 - "-" character appeared in node v13.3.0 (maybe
+    })
+    .replace(/(-|\/|:| )/g, (match, $1) => {
+      switch ($1) {
+        case "-":
+        case "/":
+        case ":":
+          return "";
+        case " ":
+          return "@";
+      }
+      return match;
+    });
+  //    return new Date().toLocaleString().replace(/(\/|:| )/g, (match, $1) => {
+  //        switch($1) {
+  //            case "/": return "-";
+  //            case ":": return "_";
+  //            case " ": return "@";
+  //        }
+  //        return match;
+  //    });
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {(dirent: import("fs").Dirent) => void} handler
+ */
+function walkDirSync(path, handler) {
+  fs.readdirSync(path, { withFileTypes: true }).forEach(handler);
+}
+
+/**
+ * write text content to dest path.
+ * when not exists parent directory, creat it.
+ *
+ * @param {string|NodeJS.ReadableStream|Buffer} content text? content.
+ * @param {string} dest content output path
+ * @param {() => void} [callback] the callback function
+ */
+function writeTextUTF8(content, dest, callback) {
+  // need dest parent dir check.
+  lib.checkParentDirectory(dest);
+
+  // actually, can write as binary
+  const ws = fs.createWriteStream(dest);
+  ws.on("error", function (err) {
+    log("WriteStream.error evnet!", arguments);
+  }).on("close", function (/*no args*/) {
+    // DEVNOTE: this event never occurs when WriteStream.write returned `true`
+    // log("[close] %s, stream closed", dest);
+    callback && callback();
+  });
+
+  if (content instanceof Buffer) {
+    content = content.toString();
+  }
+
+  if (typeof content === "string") {
+    // chunk <string> | <Buffer> | <Uint8Array> | <any>
+    const success = ws.write(content);
+    // const success = ws.write(content, function (/*no args*/) {
+    //     // log(arguments);
+    //     log("callback of WriteStream.write");
+    // });
+    // log("writeTextUTF8: write: %s,", dest, success);
+    // DEVNOTE: "drain" event callback -> WriteStream.write callback
+    //   -> WriteStream.end() => "close" event callback.
+    if (!success) {
+      ws.once("drain", function () {
+        // log("[drain] file written: %s,", dest, ws.bytesWritten);
+        ws.end(); // -> call close()
+      });
+    } else {
+      // process.nextTick(callback);
+      callback && callback();
+    }
+  }
+  // NOTE: see https://nodejs.org/dist/latest-v6.x/docs/api/stream.html#stream_readable_pipe_destination_options
+  else if ("readable" in content) {
+    // Readable stream?
+    content.pipe(ws);
+  }
+}
+
+/**
+ * @typedef {(err: any, data: string) => void} TFsCallback
+ */
+/**
+ * @template {TFsCallback | undefined} C description
+ * @template {Conditional<C, string, void>} R description
+ * @param {string} from file path.
+ * @param {C} [callback]
+ * @returns {R} description
+ */
+function readTextUTF8(from, callback) {
+  if (typeof callback === "function") {
+    fs.readFile(from, "utf8", callback);
+  } else {
+    return /** @type {R} */ (fs.readFileSync(from, "utf8"));
+  }
+  return /** @type {R} */ (undefined);
+}
+
+/**
+ * @template T
+ * @typedef {Record<string, T>} TypedRecord<T>
+ */
+/**
+ * @template T
+ * @typedef {TBD<(err: any, data: TypedRecord<T>) => void>} TReadJsonCallback
+ */
+/**
+ * NOTE: when callback specified, returns undefined
+ *
+ * @template T
+ * @template {TReadJsonCallback<T>} C description
+ * @template {Conditional<C, TypedRecord<T>, void>} R description
+ * @param {string} path file path.
+ * @param {C} [callback]
+ * @returns {R} description
+ */
+function readJson(path, callback) {
+  if (typeof callback === "function") {
+    readTextUTF8(path, (err, data) => {
+      callback(err, JSON.parse(data));
+    });
+  } else {
+    const data = readTextUTF8(path);
+    return JSON.parse(data);
+  }
+  return /** @type {R} */ (undefined);
+}
+// // OK
+// /** @type {Record<string, {}>} */
+// const config = readJson("path");
+// // OK
+// readJson("path", (err, data) => err);
+// // OK
+// const config2 = readTextUTF8("path");
+// // OK
+// readTextUTF8("path", (err, data) => err);
+
+/**
+ * use "rm-cstyle-cmts"
+ *
+ * @param {string} source
+ */
+function removeJsonComments(source) {
+  if (typeof source !== "string") {
+    throw new TypeError("invalid text content!");
+  }
+  return require("rm-cstyle-cmts")(source);
+}
+
+/** @type {(options: any) => void} */
+let nodeReplace;
+/**
+ * @param {RegExp} regex
+ * @param {string | Function} replacement
+ * @param {string[]} paths Paths that do not exist are ignored
+ * @param {boolean} [async]
+ *
+ * @date 2019-4-26
+ */
+// DEVNOTE: 2020/9/20 - Added exception handling code
+function fireReplace(regex, replacement, paths, async = false) {
+  // @ts-ignore "replace" is peerDependencies
+  nodeReplace === void 0 && (nodeReplace = require("replace"));
+  // replace init.tsx init.js ./lib/index.html && replace \\.\\/pkg\\.json ../package.json ./lib/app-properties.js
+  if (Array.isArray(paths)) {
+    // DEVNOTE: 2020/5/11 22:41:06 - exclude non exists files
+    paths = paths.filter((path) => fs.existsSync(path));
+    nodeReplace({
+      regex, //: /init\.tsx/g,
+      replacement, //: "init.js",
+      paths, //: ["./lib/index.html"],
+      recursive: false,
+      silent: false,
+      // for test?
+      preview: false,
+      // replace function.
+      // funcFile: "js source path",
+      //
+      async,
+      // regexp flags, if "regex" are plain string then needed.
+      ignoreCase: false,
+      multiline: false,
+    });
+  } else {
+    throw new Error(`invalid paths parameter: paths=[${paths}]`);
+  }
+}
+
+/**
+ * create sourceName zip. (using zip.min.js
+ *
+ * @param {string} scriptPath simple script file name. e.g - webpack (original path are "./lib/webpack.js")
+ * @param {string} comment the zip file comment.
+ */
+function compressScript(scriptPath, comment = "") {
+  // @ts-ignore
+  const zlibZip = require("./lib/zip.min").Zlib.Zip;
+  // const zlibZip = require("zlibjs/bin/zip.min").Zlib.Zip;
+  const zip = new zlibZip();
+
+  const scriptBin = fs.readFileSync(scriptPath);
+  // plainData1
+  zip.addFile(scriptBin, {
+    // filename: stringToByteArray("webpack.js"),
+    filename: stringToByteArray(path.basename(scriptPath)),
+    comment: stringToByteArray(comment),
+    // STORE or DEFLATE, default: DEFLATE...?
+    compressionMethod: zlibZip.CompressionMethod.DEFLATE,
+    os: zlibZip.OperatingSystem.MSDOS,
+  });
+
+  console.log(`added ${scriptPath} to zip`);
+  console.log("start compress...");
+  console.time("zip:compress");
+  const compressed = zip.compress();
+  console.timeEnd("zip:compress");
+  console.log("compress done.\n");
+
+  const pp = path.parse(scriptPath);
+  const output = `${pp.dir ? pp.dir + "/" : ""}${pp.name}.zip`;
+  fs.writeFile(output, compressed, (err) => {
+    console.log(`\nzip file created, error: ${err}\n => ${output}`);
+  });
+
+  /**
+   * @param {string} str
+   */
+  function stringToByteArray(str) {
+    const array = new Uint8Array(str.length);
+    for (let i = 0, il = str.length; i < il; ++i) {
+      array[i] = str.charCodeAt(i) & 0xff;
+    }
+    return array;
+  }
+}
+
+/**
+ * DEVNOTE: 10/21/2018, 9:15:00 PM - using "archiver" package, this is too fast!.
+ *
+ * @param {string} scriptPath
+ * @param {string} comment
+ */
+function compressScript2(scriptPath, comment = "") {
+  // DEVNOTE: if want use "archiver" then install to npm global
+  const archiver = require("archiver");
+  const archive = archiver("zip", {
+    // comment, deplicated, unzip.min will fail decompress...
+    zlib: { level: 9 }, // Sets the compression level.
+  });
+  const pp = path.parse(scriptPath);
+  const output = fs.createWriteStream(`${pp.dir}/${pp.name}.zip`);
+  output.on("close", function () {
+    console.log(archive.pointer() + " total bytes");
+    console.log(
+      "archiver has been finalized and the output file descriptor has closed.",
+    );
+  });
+  output.on("end", function () {
+    console.log("Data has been drained");
+  });
+  // TODO: write code.
+  archive.on("progress", (progress) => {
+    console.log(progress.entries.processed);
+  });
+  archive.pipe(output);
+  // option name は必ず指定 (entry name となるため
+  archive.file(scriptPath, {
+    name: path.basename(scriptPath),
+    // DEVNOTE: "comment" are not entry at @types. however, it is entered in zip-stream.
+    // @ts-ignore ignore mistake of type definition
+    comment,
+  });
+  archive.finalize();
+}
+
+/**
+ * it is bundled in webpack.js, other code becomes unnecessary.(at webpack
+ *
+ *   + 📝 using "exec" internally
+ *     * 🆗️ can use pipe command
+ *
+ * @param {string} command
+ * @param {string=} cwd 2025/2/1 current working directory
+ * @param {(result: string) => void} doneCallbackWithArgs gulp callback function.
+ */
+function execWithOutputResult(command, doneCallbackWithArgs, cwd) {
+  // const process = require("child_process");
+  console.log();
+  const { exec } = require("child_process");
+  return exec(command, { cwd }, (err, stdout /* , stderr */) => {
+    if (err) {
+      console.error(err);
+    } else {
+      doneCallbackWithArgs(stdout);
+    }
+  });
+}
+
+/**
+ *
+ * @param {string} list
+ */
+const NPM_INSTALL_SCRIPT = (list) => `
+@echo off
+rem REVISION LOG ENTRY
+rem
+rem File name  : npm-upg.cmd
+rem Revision By: Copyright 2020 Hiroyuki Tominaga, All Rights Reserved.
+rem 
+rem 9:26 2018/06/27 When executed in batch - npm ERR! Maximum call stack size exceeded
+rem
+
+set opt=
+if not "%1" == "" (
+    set opt=%1
+) else (
+    set opt=i
+)
+
+rem workbox-cli@4 is too large
+rem \`node-sass\` will complete more smoothly if installed separately
+rem \`windows-build-tools\` - It is better to start PowerShell with administrator privileges and install
+
+REM TODO: automation script by nodejs
+REM + child_process("npm -g outdated") -> get output
+REM + extract outdated packages by regex
+REM + output install script
+
+set LIST=${list}
+
+echo packages="%LIST%"
+npm %opt% -g %LIST%
+`;
+/**
+ * ### generate npm global package update script (windows command)
+ *
+ * ```js
+ * const utils = require("./utils");
+ * // ...
+ * // execute normally
+ * utils.genGlobalNpmUpdateScript("electron", "workbox-cli");
+ * // debug
+ * utils.genGlobalNpmUpdateScript("--debug", "electron", "workbox-cli");
+ * ```
+ *
+ * @param  {string[]} excludes
+ */
+function genGlobalNpmUpdateScript(...excludes) {
+  let debug = false;
+  if (excludes.length && excludes[0] === "--debug") {
+    debug = true;
+    excludes.shift();
+  }
+
+  console.log("run `npm -g outdated`");
+  // const progress = createProgressObject(aa, aa, aa);
+  // progress.run();
+  execWithOutputResult("npm -g outdated", (output) => {
+    console.log("done `npm -g outdated`");
+    /** @type {RegExpExecArray | null} */
+    let m;
+    /** @type {string[]} */
+    const packages = [];
+    const re = /^([\w-]+)/gm; // DEVNOTE: must use multi line flag
+    while ((m = re.exec(output))) {
+      const name = m[1];
+      if (name !== "Package" && !excludes.includes(name)) {
+        packages.push(name);
+      }
+    }
+    const packageList = packages.join("^\n ");
+    const source = NPM_INSTALL_SCRIPT(packageList);
+    if (!debug) {
+      writeTextUTF8(source, "./tmp/npm-upg.cmd");
+    } else {
+      console.log(source);
+    }
+  });
+}
+/* [simple test of `globalNpmUpdate`]
+const dummy = (output: string) => {
+    let m: RegExpExecArray | null;
+    const packages: string[] = [];
+    const re = /^([\w-]+)/gm;
+    while (m = re.exec(output)) {
+        const name = m[1];
+        if (name !== "Package" && !excludes.includes(name)) {
+            packages.push(name);
+        }
+    }
+    const packageList = packages.join("^\n ");
+    const source = NPM_INSTALL_SCRIPT(packageList);
+    // if (!debug) {
+    //     writeTextUTF8(source, "./tmp/npm-upg.cmd");
+    // } else {
+    //     console.log(source);
+    // }
+    console.log(source);
+};
+
+//
+//     for TEST code
+//
+const excludes = [
+    "electron", "workbox-cli"
+];
+const outdatedResult = `Package            Current  Wanted  Latest  Location
+create-react-app     3.4.0   3.4.1   3.4.1  global
+electron             8.0.1   8.2.0   8.2.0  global
+firebase            7.12.0  7.13.1  7.13.1  global
+firebase-tools      7.15.1  7.16.1  7.16.1  global
+npm-check-updates    4.0.4   4.1.0   4.1.0  global
+ts-node              8.7.0   8.8.1   8.8.1  global
+typedoc             0.17.1  0.17.3  0.17.3  global
+webpack             4.42.0  4.42.1  4.42.1  global
+workbox-cli          4.3.1   4.3.1   5.1.2  global
+`;
+// run test
+dummy(outdatedResult);
+*/
+
+/**
+ * ### command:
+ *
+ *   + windows - chcp 65001 && clip
+ *   + others  - xclip
+ *
+ * @param {string} content the copy terget content as string.
+ * @param {string} [message] default: "text copied!"
+ * @param {boolean} [chcp65001] default `true`
+ */
+function copyText(content, message = "text copied!", chcp65001 = true) {
+  const os = require("os");
+  const cp = require("child_process");
+  const command =
+    os.platform() === "win32"
+      ? `${chcp65001 ? "chcp 65001 && " : ""}clip`
+      : "xclip";
+  const clipTask = () => {
+    const childProc = cp.exec(command, (err, stdout) => {
+      if (err) {
+        console.error(err);
+      } else {
+        console.log(message, stdout);
+      }
+    });
+    // @ts-ignore
+    childProc.stdin.write(content, (error) => {
+      if (error) {
+        console.error(error);
+      }
+      // DEVNOTE: do noting...
+      // util.inspect("content_for_the_clipboard");
+      // @ts-ignore
+      childProc.stdin.end();
+    });
+  };
+
+  clipTask();
+  // if (os.platform() === "win32") {
+  //     // clipTask();
+  //     cp.exec("chcp", (err, stdout) => {
+  //             if (err) {
+  //                 console.error(err);
+  //             } else {
+  //                 if (!stdout.includes("65001")) {
+  //                     console.log("OKKKK");
+  //                     clipTask();
+  //                 }
+  //             }
+  //         }
+  //     );
+  // } else {
+  //     clipTask();
+  // }
+}
+
+/**
+ * use for gulp.dest(...)
+ *
+ * **useful when glob pattern can not be used (when path must be explicitly specified).**
+ *
+ * ```js
+ *  gulp.src([
+ *      "./src/app-config.ts",
+ *      "./src/auth/{eve-sso,eve-sso-v2e}.php"
+ *  ]).pipe(
+ *      ...
+ *  ).pipe(gulp.dest((vinyl) => {
+ *      return convertRelativeDir(vinyl);
+ *  })).on("end", () => {
+ *      console.log("done");
+ *  });
+ * ```
+ * @param {import("vinyl")} vinyl
+ * @param {string} dest default is "." -> node launched directory. (cwd?)
+ */
+function convertRelativeDir(vinyl, dest = ".") {
+  // NOTE: vinyl is https://github.com/gulpjs/vinyl
+  // if (false) {
+  //     console.log("convertRelativeDir::debug log");
+  //     console.log(vinyl.cwd);
+  //     console.log(vinyl.base);
+  // }
+  let x = vinyl.cwd.length + 1;
+  let relative_dir = vinyl.base.substring(x);
+  return `${dest}/${relative_dir}`;
+}
+
+/**
+ * prepend `content` to the beginning of each element of `str_array`
+ *
+ * form:
+ * ```js
+ * `${content}${suffix}${<str_array element>}`
+ * ```
+ *
+ * @param {string[]} str_array the string array
+ * @param {string} content prepend content
+ * @param {string} [suffix]
+ * @date 2020/2/16
+ * @version 2.0 rename `appendStringTo` -> `prependStringTo`
+ */
+function prependStringTo(str_array, content, suffix = "") {
+  /** @type {string} */
+  let target;
+  for (let i = 0; (target = str_array[i]); ) {
+    str_array[i++] = `${content}${suffix}${target}`;
+  }
+}
+
+module.exports = {
+  prependStringTo,
+
+  extractVersion,
+  dateStringForFile,
+  getExtraArgs,
+  removeJsonComments,
+  writeTextUTF8,
+  readTextUTF8,
+  readJson,
+  walkDirSync,
+
+  compressScript,
+  compressScript2,
+  execWithOutputResult,
+  genGlobalNpmUpdateScript,
+  convertRelativeDir,
+  /**
+   *
+   * @param {string} content the copy terget content as string.
+   * @param {string} message default: "text copied!"
+   */
+  copyText,
+  fireReplace,
+  CI,
+  log,
+};