js-dev-tool 1.0.0

package/lib/zlibjs.d.ts

@@ -0,0 +1,34 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  <one line to give the program's name and a brief idea of what it does.>
+  Copyright (C) 2018 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/>.
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+*/
+declare interface IUnzip {
+    new(data: Uint8Array): this;
+    getFilenames(): string[];
+    decompress(entry: string): Uint8Array;
+    getCommentAsString(): string;
+    getFileHeader(index: number): {
+        getCommentAsString(): string;
+    };
+}
+declare namespace Zlib {
+    const Unzip: IUnzip;
+}
+interface Window {
+    Zlib: typeof Zlib;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "js-dev-tool",
+  "version": "1.0.0",
+  "bin": {
+    "jstool": "./tools.js"
+  },
+  "types": "./index.d.ts",
+  "main": "./index.js",
+  "repository": "git@github.com:jeffy-g/js-dev-scripts.git",
+  "author": "jeffy-g <hirotom1107@gmail.com>",
+  "license": "MIT",
+  "keywords": [
+    "js",
+    "ts",
+    "javascript",
+    "typescript",
+    "command",
+    "command line",
+    "version"
+  ],
+  "files": [
+    "common",
+    "extras",
+    "lib",
+    "progress",
+    "scripts",
+    "tool-lib",
+    "index.js",
+    "tools.js",
+    "utils.js",
+    "tsconfig.json",
+    "!scripts/unzip.ts",
+    "!scripts/bin",
+    "!extras/npm",
+    "!/**/*.png",
+    "!tool.sh",
+    "*.d.ts"
+  ],
+  "peerDependencies": {
+    "archiver": "^4.0.1"
+  },
+  "dependencies": {
+    "colors.ts": "^1.0.20",
+    "fflate": "^0.8.2",
+    "mini-semaphore": "^1.4.4",
+    "replace": "^1.2.2",
+    "rm-cstyle-cmts": "^3.3.22",
+    "terser": "^5.44.1",
+    "tin-args": "^0.0.15"
+  }
+}

package/progress/index.d.ts

@@ -0,0 +1,92 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2022 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+export type TProgressFormatOptions = {
+    fmt: string;
+    payload?: Record<string, string>;
+};
+/**
+ * create async progress
+ *
+ * @param {number} timeSpanMS controll rotator cycle speed (ms). (maybe about...
+ * @param {string[]} frames progress frame.
+ */
+export function createProgress(timeSpanMS: number, frames: string[]): (text: string) => void;
+/**
+ *
+ * @param {string[]} frames progress frame.
+ * @param {{ fmt: string, payload?: Record<string, string> }} [formatOpt]
+ * ```
+ * " {frameName} [{tick}]: {msg}" // etc
+ * ```
+ */
+export function createProgressSync(frames: string[], formatOpt?: {
+    fmt: string;
+    payload?: Record<string, string>;
+}): (msg: string, done?: boolean) => void;
+
+/**
+ *
+ * @param {string[]} frames progress frame.
+ * @param {TProgressFormatOptions} formatOpt
+ * ```
+ * " {frameName} [{tick}]: {msg}" // etc
+ * ```
+ * @param {() => string} callback
+ */
+export function createProgressObject(frames: string[], formatOpt: TProgressFormatOptions, callback: () => string): {
+    /**
+     * @param {string[]} [newFrames]
+     * @param {TProgressFormatOptions} [newOpt]
+     */
+    updateOptions(newFrames?: string[], newOpt?: TProgressFormatOptions): void;
+    /**
+     * which means progress done
+     */
+    deadline(): void;
+    /**
+     * adjust to next line
+     */
+    newLine(): void;
+    /**
+     * change the fps rate
+     *
+     * @param {number} fps
+     */
+    setFPS(fps: number): void;
+    /**
+     * render progress as sync
+     * 
+     * this method useful when `run` method did not smooth.
+     */
+    renderSync(): void;
+    /**
+     * run timer (30fps)
+     */
+    run(): void;
+    /**
+     * stop timer
+     */
+    stop(): void;
+};
+
+declare global {
+    type TWebpackProgressHandler = (percentage: number, message: string, ...args: string[]) => void;
+}
+/**
+ * see https://webpack.js.org/plugins/progress-plugin/
+ *
+ * @param {string} [logFilePath] can be undefined
+ * @param {boolean} [disableRenderLine]
+ */
+export function createWebpackProgressPluginHandler(logFilePath?: string, disableRenderLine?: boolean): (percentage: number, message: string, ...args: string[]) => void;
+/**
+ * logger for browserify
+ *
+ * @param {string} logFilePath log output path name.
+ */
+export function createBrowserifyFileEventLogger(logFilePath: string): (counter: number, message: string, ...args: string[]) => void;

package/progress/index.js

@@ -0,0 +1,305 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2022 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+const lib = require("../common");
+const {
+  checkENV,
+  wppHandlerV5,
+  wppHandlerV4,
+  isWebpackV5later,
+} = require("./progress-extras");
+
+/**
+ *
+ * @param {string[]} frames progress frame.
+ * @param {{ fmt: string, payload?: Record<string, string> }} [formatOpt]
+ * ```
+ * " {frameName} [{tick}]: {msg}" // etc
+ * ```
+ */
+const createProgressSync = (frames, formatOpt) => {
+  const fsize = frames.length;
+  let index = 0;
+  /** @type {string} */
+  let fmt;
+  /** @type {Record<string, string>} */
+  let payload;
+  /** @type {string[]} */
+  let keys;
+  if (formatOpt) {
+    fmt = formatOpt.fmt;
+    // FIXME: 2023/10/27 - which use payload?
+    payload = formatOpt.payload || {};
+    keys = Object.keys(payload);
+  }
+  /**
+   * @param {string} tick
+   * @param {string} msg
+   */
+  const formater = (tick, msg) => {
+    if (fmt) {
+      let content = fmt;
+      for (let i = 0, end = keys.length; i < end; ) {
+        const key = keys[i++];
+        content = content.replace("{" + key + "}", payload[key]);
+      }
+      return content.replace("{tick}", tick).replace("{msg}", msg);
+    }
+    return `[${tick}]: ${msg}`;
+  };
+  // let prev = "";
+  return /**@type {(msg: string, done?: boolean) => void}*/ (
+    msg,
+    done = false,
+  ) => {
+    const tick = done ? "-done-" : frames[index++ % fsize];
+    const line = msg ? formater(tick, msg) : "";
+    lib.renderLine(line);
+    // if (line) {
+    //     // if (prev !== line) {
+    //     //     renderLine(line);
+    //     //     prev = line;
+    //     // }
+    //     lib.renderLine(line);
+    // } else {
+    //     lib.renderLine();
+    // }
+    // // !line && (renderLine(), 1) || renderLine(line);
+  };
+};
+
+/**
+ * @typedef {{ fmt: string, payload?: Record<string, string> }} TProgressFormatOptions
+ */
+/**
+ *
+ * @param {string[]} frames progress frame.
+ * @param {TProgressFormatOptions} formatOpt
+ * ```
+ * " {frameName} [{tick}]: {msg}" // etc
+ * ```
+ * @param {() => string} callback
+ */
+const createProgressObject = (frames, formatOpt, callback) => {
+  let done = false;
+  const render = () => {
+    // DEVNOTE: 2025/01/24 - やはりこれがいいね...
+    process.nextTick(progress, callback(), done);
+    // progress(callback(), done);
+  };
+
+  let progress = createProgressSync(frames, formatOpt);
+  /** @type {ReturnType<typeof setInterval> | undefined} */
+  let timer;
+  let ms = 33;
+
+  // progressObject
+  return {
+    /**
+     * @param {string[]} [newFrames]
+     * @param {TProgressFormatOptions} [newOpt]
+     */
+    updateOptions(newFrames, newOpt) {
+      if (Array.isArray(newFrames) && typeof newFrames[0] === "string") {
+        frames = newFrames;
+      }
+      if (typeof newOpt === "object" && newOpt.fmt) {
+        formatOpt = newOpt;
+      }
+      done = false;
+      progress = createProgressSync(frames, formatOpt);
+    },
+    /**
+     * which means progress done
+     */
+    deadline() {
+      (done = true), render();
+    },
+    /**
+     * adjust to next line
+     */
+    newLine() {
+      console.log();
+    },
+    /**
+     * change the fps rate
+     *
+     * @param {number} fps
+     */
+    setFPS(fps) {
+      ms = (1000 / fps) | 0;
+      if (timer) {
+        clearInterval(timer);
+        timer = setInterval(render, ms);
+      }
+    },
+    /**
+     * render progress as sync
+     *
+     * this method useful when `run` method did not smooth.
+     */
+    renderSync() {
+      render();
+    },
+    /**
+     * run timer (30fps)
+     */
+    run() {
+      lib.cursor(false);
+      done = false;
+      if (timer) {
+        return;
+      }
+      timer = setInterval(render, ms);
+    },
+    /**
+     * stop timer
+     */
+    stop() {
+      done = true;
+      clearInterval(timer);
+      timer = void 0;
+      lib.cursor(true);
+    },
+  };
+};
+
+/**
+ * create async progress
+ *
+ * @param {number} timeSpanMS controll rotator cycle speed (ms). (maybe about...
+ * @param {string[]} frames progress frame.
+ */
+const createProgress = (timeSpanMS, frames) => {
+  // let index = 0;
+  // return /**@type {(text: string) => void}*/ text => {
+  //     const line = text === void 0? "" : `[${frames[index++ % frames.length]}]: ${text}`;
+  //     !line && (progress(), 1) || process.nextTick(progress, line);
+  // }
+  const { performance } = require("perf_hooks");
+
+  let index = 0;
+  const fsize = frames.length;
+  let x = performance.now();
+  return /**@type {(text: string) => void}*/ (text) => {
+    const x2 = performance.now();
+    const line = text === void 0 ? "" : `[${frames[index % fsize]}]: ${text}`;
+    if (x2 - x > timeSpanMS) {
+      index++;
+    }
+    x = x2;
+    (!line && (lib.renderLine(), 1)) || process.nextTick(lib.renderLine, line);
+  };
+};
+
+/**
+ * see https://webpack.js.org/plugins/progress-plugin/
+ *
+ * @param {string} [logFilePath] can be undefined
+ * @param {boolean} [disableRenderLine]
+ * @version 2.0 detect webpack version(v4 or v5)
+ * @version 2.1 detect gitpod process
+ */
+function createWebpackProgressPluginHandler(
+  logFilePath,
+  disableRenderLine = false,
+) {
+  const formatPercentage = (/** @type {number} */ pct) => {
+    return `processing ${(pct * 100).toFixed(4)}%`;
+  };
+
+  let dotted = 0;
+  const renderDot = () => {
+    process.stderr.write(".");
+    // FIXME: first renderDot line length is not 100
+    dotted++;
+    if (dotted % 100 === 0) {
+      process.stderr.write("\n");
+    }
+  };
+  /** @type {((msg?: string) => void) | undefined} */
+  const renderer = process.env.CI ? renderDot : lib.renderLine;
+
+  // (percentage: number, msg: string, moduleProgress?: string, activeModules?: string, moduleName?: string) => void
+  /** @type {TWebpackProgressHandler} */
+  let wppHandler;
+  {
+    const shorttenProgress = (/** @type {number} */ pct) => {
+      renderer(formatPercentage(pct));
+      pct === 1 && (console.log(), (dotted = 0));
+    };
+    if (logFilePath !== void 0) {
+      const wppLogger = lib.createLogStreamAndResolvePath(logFilePath);
+      /** @type {((p: number) => void) | undefined} */
+      let writeCallback;
+
+      if (!disableRenderLine) {
+        writeCallback = shorttenProgress;
+      }
+      wppHandler = (percentage, message, ...args) => {
+        wppLogger.write(
+          `${formatPercentage(percentage)}, ${message}: ${args}\n`,
+          () => {
+            writeCallback && writeCallback(percentage);
+          },
+        );
+        percentage === 1 && wppLogger.end();
+      };
+    } else {
+      if (disableRenderLine) {
+        // DEVNOTE: 2022/02/16 ignore CI process
+        wppHandler = () => {};
+      } else {
+        const processType = checkENV();
+        if (processType === "ci") {
+          wppHandler = renderDot;
+        } else {
+          if (processType === "gitpod") {
+            wppHandler = shorttenProgress;
+          } else {
+            wppHandler = isWebpackV5later() ? wppHandlerV5 : wppHandlerV4;
+          }
+        }
+      }
+    }
+  }
+
+  return wppHandler;
+}
+
+/**
+ * logger for browserify
+ *
+ * @param {string} logFilePath log output path name.
+ */
+function createBrowserifyFileEventLogger(logFilePath) {
+  const log = lib.createLogStreamAndResolvePath(logFilePath);
+  /**
+   * write browserify file event data.
+   *
+   * @type {(counter: number, message: string, ...args: string[]) => void} */
+  const logger = (counter, message, ...args) => {
+    if (counter === void 0) {
+      log.end();
+      return;
+    }
+    const progressMessage = `resolve - ${counter}`;
+    log.write(`${progressMessage}, ${message}: ${args}\n`, () => {
+      lib.renderLine(progressMessage);
+    });
+  };
+  return logger;
+}
+
+module.exports = {
+  createProgress,
+  createProgressSync,
+  createProgressObject,
+
+  createWebpackProgressPluginHandler,
+  createBrowserifyFileEventLogger,
+};

package/progress/progress-extras.js

@@ -0,0 +1,90 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2022 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/// <reference path="./index.d.ts"/>
+const lib = require("../common");
+
+const checkENV = () => {
+  const env = process.env;
+  if (env.CI) return "ci";
+  for (const k of Object.keys(env)) {
+    if (k.startsWith("GITPOD_")) return "gitpod";
+  }
+  return "maybe-local";
+};
+/** @type {TWebpackProgressHandler} */
+const wppHandlerV4 = ((renderer, cwd) => {
+  return (percentage, message, ...args) => {
+    // DEVNOTE: 2022/02/16 these values are webpack v4 (maybe
+    let [modules, actives, path = ""] = args;
+    // let [modules, actives, path = ""] = args;
+    if (message) {
+      const x = path.lastIndexOf(cwd) + 1;
+      x > 0 && (path = path.substring(x + cwd.length));
+    } else {
+      // which means all processing done
+      message = "- done -";
+    }
+    // TODO: 2022/2/16 webpack version 5 is different parameters
+    //   so rewrite it.
+    renderer(
+      `processing ${(percentage * 100).toFixed(4)}% | ` +
+        message +
+        ` [${modules}, ${actives}] ${path}`,
+    );
+    percentage === 1 && console.log();
+  };
+})(lib.renderLine, process.cwd());
+
+/** @type {TWebpackProgressHandler} */
+const wppHandlerV5 = ((renderer, cwd) => {
+  return (percentage, message, ...args) => {
+    if (!message) {
+      message = "- done -";
+    }
+    // plugin name or source path
+    let str = args[1];
+    if (str) {
+      const x = str.lastIndexOf(cwd) + 1;
+      if (x > 0) {
+        args[1] = str.substring(x + cwd.length);
+      }
+    }
+    str = args.shift() || "";
+    renderer(
+      `pct: ${(percentage * 100).toFixed(4)}%, process: [${message}]${str ? `, info: [${str}]` : ""}${args.length ? " - " : ""}${args.join(", ")}`,
+    );
+    // console.log(`pct: ${(percentage*100).toFixed(4)}%, process: [${message}]${ str? `, info: [${str}]`: "" }${ args.length? " -": "" }`, args.join(", "));
+    percentage === 1 && console.log();
+  };
+})(lib.renderLine, process.cwd());
+
+/** @type {boolean} */
+let checkedCache;
+/**
+ * @type {() => boolean}
+ */
+const isWebpackV5later = () => {
+  if (checkedCache === void 0) {
+    try {
+      // @ts-ignore
+      const webpack = require("webpack");
+      checkedCache = +webpack.version[0] > 4;
+    } catch (e) {
+      console.info(e);
+      checkedCache = false;
+    }
+  }
+  return checkedCache;
+};
+
+module.exports = {
+  checkENV,
+  wppHandlerV4,
+  wppHandlerV5,
+  isWebpackV5later,
+};

package/progress/rnd-spinner.js

@@ -0,0 +1,55 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2020 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file random spinner
+ * @author jeffy-g <hirotom1107@gmail.com>
+ * @version 1.0
+ * @requires spinners.json
+ */
+/**
+ * @param {any[]} array
+ */
+const randomIndex = (array) => {
+  return Math.floor(Math.random() * array.length);
+};
+
+/**
+ * @typedef {import("./spinners")} TSpinners
+ * @typedef {keyof TSpinners} TSpinnersName
+ */
+/**
+ * @type {TSpinners}
+ */
+const spinners = require("./spinners.json");
+/**
+ * @type {TSpinnersName[]}
+ */
+// @ts-ignore
+const frameNames = Object.keys(spinners);
+
+const MAX_PAD = frameNames.reduce((acc, sn) => {
+  return Math.max(acc, sn.length);
+}, 0);
+const MIN_PAD = frameNames.reduce((acc, sn) => {
+  return Math.max(acc, sn.length);
+}, MAX_PAD);
+
+const getRandomFrame = () => {
+  /** @type {TSpinnersName} */
+  const name = frameNames[randomIndex(frameNames)]; //.frames;
+  return {
+    name,
+    frames: spinners[name].frames,
+  };
+};
+
+module.exports = {
+  getRandomFrame,
+  MAX_PAD,
+  MIN_PAD,
+};

package/progress/spinners.d.ts

@@ -0,0 +1,74 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2022 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+type TSpinners = {
+    dots: Dots;
+    dots2: Dots;
+    dots3: Dots;
+    dots4: Dots;
+    dots5: Dots;
+    dots6: Dots;
+    dots7: Dots;
+    dots8: Dots;
+    dots9: Dots;
+    dots10: Dots;
+    dots11: Dots;
+    dots12: Dots;
+    line: Dots;
+    line2: Dots;
+    pipe: Dots;
+    simpleDots: Dots;
+    simpleDotsScrolling: Dots;
+    star: Dots;
+    star2: Dots;
+    flip: Dots;
+    hamburger: Dots;
+    growVertical: Dots;
+    growHorizontal: Dots;
+    balloon: Dots;
+    balloon2: Dots;
+    noise: Dots;
+    bounce: Dots;
+    boxBounce: Dots;
+    boxBounce2: Dots;
+    triangle: Dots;
+    arc: Dots;
+    circle: Dots;
+    squareCorners: Dots;
+    circleQuarters: Dots;
+    circleHalves: Dots;
+    squish: Dots;
+    toggle2: Dots;
+    toggle3: Dots;
+    toggle4: Dots;
+    toggle5: Dots;
+    toggle7: Dots;
+    toggle8: Dots;
+    toggle9: Dots;
+    toggle10: Dots;
+    toggle12: Dots;
+    toggle13: Dots;
+    arrow: Dots;
+    arrow2: Dots;
+    arrow3: Dots;
+    bouncingBar: Dots;
+    bouncingBall: Dots;
+    pong: Dots;
+    airplain: Dots;
+    shark: Dots;
+    dqpb: Dots;
+    grenade: Dots;
+    point: Dots;
+    layer: Dots;
+}
+
+interface Dots {
+    interval: number;
+    frames: string[];
+}
+
+export = TSpinners;