rescript

#!/usr/bin/env node
//@ts-check
"use strict";

/* This script is supposed to be running in project root directory
 * It matters since we need read .sourcedirs(location)
 * and its content are file/directories with regard to project root
 */

var child_process = require("child_process");
var os = require("os");
var path = require("path");
var fs = require("fs");
var bsconfig = "bsconfig.json";
var bsb_exe = path.join(__dirname, process.platform, "rescript.exe");

var LAST_BUILD_START = 0;
/**
 * @type {[string,string][]}
 */
var reasons_to_rebuild = [];

var LAST_SUCCESS_BUILD_STAMP = 0;
var cwd = process.cwd();
var lockFileName = path.join(cwd, ".bsb.lock");
process.env.BSB_PROJECT_ROOT = cwd;
// console.log('BSB_PROJECT_ROOT:', process.env.BSB_PROJECT_ROOT)

// All clients of type MiniWebSocket
/**
 * @type {any[]}
 */
var wsClients = [];
var watch_mode = false;
var verbose = false;
/**
 * @type {string | undefined}
 */
var postBuild = undefined;
var useWebSocket = false;
var webSocketHost = "localhost";
var webSocketPort = 9999;

/**
 * @returns {string}
 */
function getDateAsString() {
  var n = new Date();
  return (
    n.getHours() +
    ":" +
    n.getMinutes() +
    ":" +
    n.getSeconds() +
    ":" +
    n.getMilliseconds()
  );
}
/**
 * @time{[number,number]}
 */
var startTime;
function updateStartTime() {
  startTime = process.hrtime();
  return "";
}
function updateFinishTime() {
  var diff = process.hrtime(startTime);
  return diff[0] * 1e9 + diff[1];
}

/**
 *
 * @param {string} file
 * @returns
 */
function getWatchFiles(file) {
  if (fs.existsSync(file)) {
    return JSON.parse(fs.readFileSync(file, "utf8"));
  } else {
    return { dirs: [], generated: [] };
  }
}

/**
 *
 * @param {*} str
 */
function dlog(str) {
  if (verbose) {
    console.log(str);
  }
}
function notifyClients() {
  wsClients = wsClients.filter((x) => !x.closed && !x.socket.destroyed);
  var wsClientsLen = wsClients.length;
  dlog(`Alive sockets number: ${wsClientsLen}`);
  var data = JSON.stringify({
    LAST_SUCCESS_BUILD_STAMP: LAST_SUCCESS_BUILD_STAMP,
  });
  for (var i = 0; i < wsClientsLen; ++i) {
    // in reverse order, the last pushed get notified earlier
    var client = wsClients[wsClientsLen - i - 1];
    if (!client.closed) {
      client.sendText(data);
    }
  }
}

function setUpWebSocket() {
  var WebSocket = require("./lib/minisocket.js").MiniWebSocket;
  var id = setInterval(notifyClients, 3000);
  require("http")
    .createServer()
    .on("upgrade", function (req, socket, upgradeHead) {
      dlog("connection opened");
      var ws = new WebSocket(req, socket, upgradeHead);
      socket.on("error", function (err) {
        dlog(`Socket Error ${err}`);
      });
      wsClients.push(ws);
    })
    .on("error", function (err) {
      // @ts-ignore
      if (err !== undefined && err.code === "EADDRINUSE") {
        var error = std_is_tty ? `\x1b[1;31mERROR:\x1b[0m` : `ERROR:`;
        console.error(`${error} The websocket port number ${webSocketPort} is in use. 
Please pick a different one using the \`-ws [host:]port\` flag from bsb.`);
      } else {
        console.error(err);
      }
      process.exit(2);
    })
    .listen(webSocketPort, webSocketHost);
}

/**
 * @type {string[]}
 */
var delegate_args = [];
var process_argv = process.argv;

if (process.env.NINJA_ANSI_FORCED === undefined) {
  if (require("tty").isatty(1)) {
    process.env.NINJA_ANSI_FORCED = "1";
  }
} else {
  dlog(`NINJA_ANSI_FORCED: "${process.env.NINJA_ANSI_FORCED}"`);
}
function help() {
  console.log(`Available flags
-v, -version  display version number
-h, -help     display help 
Subcommands:
    build    
    clean
    format
    convert
    help
Run rescript subcommand -h for more details,
For example:
    rescript build -h
    rescript format -h
The default \`rescript\` is equivalent to \`rescript build\` subcommand
  `);
}

var maybe_subcommand = process_argv[2];
var is_building = false;
function releaseBuild() {
  is_building = false;
}
function acquireBuild() {
  if (is_building) {
    return false;
  } else {
    is_building = true;
    return true;
  }
}

if (
  maybe_subcommand !== undefined &&
  maybe_subcommand !== "build" &&
  maybe_subcommand !== "clean" &&
  maybe_subcommand !== "init" &&
  maybe_subcommand !== "info"
  // delegate to native
) {
  var bsc_exe = path.join(__dirname, process.platform, "bsc.exe");
  switch (maybe_subcommand) {
    case "format":
      require("./scripts/rescript_format.js").main(
        process.argv.slice(3),
        bsb_exe,
        bsc_exe
      );
      break;
    case "convert":
      // Todo
      require("./scripts/rescript_convert.js").main(
        process.argv.slice(3),
        bsb_exe,
        bsc_exe
      );
      break;
    case "-h":
    case "-help":
    case "help":
      help();
      break;
    case "-v":
    case "-version":
      console.log(require("./package.json").version);
      break;
    default:
      console.error(`Unknown subcommand or flags: ${maybe_subcommand}`);
      help();
      process.exit(2);
  }
} else {
  var delegate_args = process_argv.slice(2);
  var watch_mode = delegate_args.includes("-w");
  var wsParamIndex = delegate_args.indexOf("-ws");
  if (wsParamIndex > -1) {
    var hostAndPortNumber = (process_argv[wsParamIndex + 1] || "").split(":");
    /**
     * @type {number}
     */
    var portNumber;
    if (hostAndPortNumber.length === 1) {
      portNumber = parseInt(hostAndPortNumber[0]);
    } else {
      webSocketHost = hostAndPortNumber[0];
      portNumber = parseInt(hostAndPortNumber[1]);
    }
    if (!isNaN(portNumber)) {
      webSocketPort = portNumber;
    }
    useWebSocket = true;
    dlog(`WebSocket host & port number: ${webSocketHost}:${webSocketPort}`);
  }

  verbose = delegate_args.includes("-verbose");
  /**
   * @type {child_process.ChildProcess}
   */
  var p;
  try {
    p = child_process.spawn(bsb_exe, delegate_args, { stdio: "inherit" });
    LAST_BUILD_START = +Date.now();
  } catch (e) {
    if (e.code === "ENOENT") {
      // when bsb is actually not found
      console.error(String(e));
    }
    process.exit(2);
  }

  p.on("close", (code, signal) => {
    if (code !== 0) {
      process.exit(code);
    } else if (watch_mode) {
      in_watch_mode(useWebSocket);
    }
  });

  /**
   *
   * @param {boolean} useWebSocket
   */
  function in_watch_mode(useWebSocket) {
    if (useWebSocket) {
      setUpWebSocket();
    }
    // for column one based error message

    /**
     * watchers are held so that we close it later
     */
    var watchers = [];

    function onUncaughtException(err) {
      console.error("Uncaught Exception", err);
      process.exit(1);
    }
    function onExit() {
      try {
        fs.unlinkSync(lockFileName);
      } catch (err) {
        process.exitCode = 1;
      }
    }
    function exitProcess() {
      process.exit(0);
    }

    /**
     * @return {boolean}
     */
    function acquireLockFile() {
      try {
        // We use [~perm:0o664] rather than our usual default perms, [0o666], because
        // lock files shouldn't rely on the umask to disallow tampering by other.
        var fd = fs.openSync(lockFileName, "wx", 0o664);
        try {
          fs.writeFileSync(fd, String(process.pid), "ascii");
          fs.closeSync(fd);
        } catch (err) {}

        process.on("exit", onExit);
        process.on("uncaughtException", onUncaughtException);

        // OS signal handlers
        // Ctrl+C
        process.on("SIGINT", exitProcess);
        // kill pid
        process.on("SIGUSR1", exitProcess);
        process.on("SIGUSR2", exitProcess);
        process.on("SIGTERM", exitProcess);
        process.on("SIGHUP", exitProcess);

        process.stdin.on("close", exitProcess);
        // close when stdin stops
        if (os.platform() !== "win32") {
          process.stdin.on("end", exitProcess);
          process.stdin.resume();
        }

        return true;
      } catch (exn) {
        return false;
      }
    }

    var sourcedirs = path.join("lib", "bs", ".sourcedirs.json");
    var watch_generated = [];

    function watch_build(watch_config) {
      var watch_files = watch_config.dirs;
      watch_generated = watch_config.generated;
      // close and remove all unused watchers
      watchers = watchers.filter(function (watcher) {
        if (watcher.dir === bsconfig) {
          return true;
        } else if (watch_files.indexOf(watcher.dir) < 0) {
          dlog(`${watcher.dir} is no longer watched`);
          watcher.watcher.close();
          return false;
        } else {
          return true;
        }
      });

      // adding new watchers
      for (var i = 0; i < watch_files.length; ++i) {
        var dir = watch_files[i];
        if (
          !watchers.find(function (watcher) {
            return watcher.dir === dir;
          })
        ) {
          dlog(`watching dir ${dir} now`);
          var watcher = fs.watch(dir, on_change);
          watchers.push({ dir: dir, watcher: watcher });
        } else {
          // console.log(dir, 'already watched')
        }
      }
    }

    /**
     *
     * @param {string} eventType
     * @param {string} fileName
     */
    function validEvent(eventType, fileName) {
      // Return true if filename is nil, filename is only provided on Linux, macOS, Windows, and AIX.
      // On other systems, we just have to assume that any change is valid.
      // This could cause problems if source builds (generating js files in the same directory) are supported.
      if (!fileName) return true;

      return !(
        fileName === ".merlin" ||
        fileName.endsWith(".js") ||
        fileName.endsWith(".mjs") ||
        fileName.endsWith(".cjs") ||
        fileName.endsWith(".gen.tsx") ||
        watch_generated.indexOf(fileName) >= 0 ||
        fileName.endsWith(".swp")
      );
    }
    /**
     * @return {boolean}
     */
    function needRebuild() {
      return reasons_to_rebuild.length != 0;
    }
    var error_is_tty = process.stderr.isTTY;
    var std_is_tty = process.stdout.isTTY;
    function logFinish(code) {
      if (std_is_tty) {
        if (code === 0) {
          console.log(
            "\x1b[36m>>>> Finish compiling\x1b[0m",
            Math.floor(updateFinishTime() / 1e6),
            "mseconds"
          );
        } else {
          console.log(
            "\x1b[1;31m>>>> Finish compiling(exit: " + code + ")\x1b[0m"
          );
        }
      } else {
        if (code === 0) {
          console.log(">>>> Finish compiling");
        } else {
          console.log(">>>> Finish compiling(exit: " + code + ")");
        }
      }
    }
    function logStart() {
      if (std_is_tty) {
        console.log("\x1b[36m>>>> Start compiling\x1b[0m", updateStartTime());
      } else {
        console.log(">>>> Start compiling");
      }
    }
    /**
     *
     * @param code {number}
     * @param signal {string}
     */
    function build_finished_callback(code, signal) {
      if (code === 0) {
        LAST_SUCCESS_BUILD_STAMP = +new Date();
        notifyClients();
        if (postBuild) {
          dlog(`running postbuild command: ${postBuild}`);
          child_process.exec(postBuild);
        }
      }
      logFinish(code);
      releaseBuild();
      if (needRebuild()) {
        build();
      } else {
        var files = getWatchFiles(sourcedirs);
        watch_build(files);
      }
    }

    /**
     * TODO: how to make it captured by vscode
     * @param output {string}
     * @param highlight {string}
     */
    function error_output(output, highlight) {
      if (error_is_tty && highlight) {
        process.stderr.write(
          output.replace(highlight, "\x1b[1;31m" + highlight + "\x1b[0m")
        );
      } else {
        process.stderr.write(output);
      }
    }
    // Note this function filters the error output
    // it relies on the fact that ninja will merege stdout and stderr
    // of the compiler output, if it does not
    // then we should have a way to not filter the compiler output
    function build() {
      if (acquireBuild()) {
        logStart();
        if (reasons_to_rebuild.length === 0) {
          dlog("Rebuilding since just got started");
        } else {
          dlog(`Rebuilding since ${reasons_to_rebuild}`);
        }

        child_process
          .spawn(bsb_exe, [], {
            stdio: ["inherit", "inherit", "pipe"],
          })
          // @ts-ignore
          .on("data", function (s) {
            error_output(s, "ninja: error");
          })
          .on("exit", build_finished_callback)
          .stderr.setEncoding("utf8");
        // This is important to clean up all
        // previous queued events
        reasons_to_rebuild = [];
        LAST_BUILD_START = +Date.now();
      }
    }
    /**
     *
     * @param {string} event
     * @param {string} reason
     */
    function on_change(event, reason) {
      var event_time = +Date.now();
      var time_diff = event_time - LAST_BUILD_START;
      dlog(`Since last build : ${time_diff}`);
      if (time_diff < 5) {
        // for 5ms, we could think that the ninja not get
        // kicked yet, so there is really no need
        // to send more events here

        // note reasons_to_rebuild also
        // helps avoid redundant build, but this will
        // save the event loop call `setImmediate`
        return;
      }
      if (validEvent(event, reason)) {
        dlog(`Event ${event} ${reason}`);
        reasons_to_rebuild.push([event, reason]);
        // Some editors are using temporary files to store edits.
        // This results in two sync change events: change + rename and two sync builds.
        // Using setImmediate will ensure that only one build done.
        setImmediate(() => {
          if (needRebuild()) {
            if (process.env.BS_WATCH_CLEAR && console.clear) {
              console.clear();
            }
            build();
          }
        });
      }
    }

    /**
     *
     * @param potential_pid {number}
     */
    function existPid(potential_pid) {
      try {
        return process.kill(potential_pid, 0);
      } catch (err) {
        return false;
      }
    }

    // Initialization and get locker file
    while (true) {
      if (acquireLockFile()) {
        break;
      } else {
        var potential_pid;
        try {
          var content = fs.readFileSync(lockFileName, "ascii");
          potential_pid = parseInt(content);
        } catch (err) {
          // ignore
        }
        var validPid = potential_pid !== undefined && !isNaN(potential_pid);

        if (validPid && !existPid(potential_pid)) {
          console.log("Stale file detected : ", lockFileName);
          try {
            fs.unlinkSync(lockFileName);
          } catch (err) {}
          console.log("Retry:");
          continue;
        } else {
          error_output("Error: could not acquire lockfile", "Error");
          console.error(" " + lockFileName);

          console.log(
            "Could be another process running in the background",
            "\nEither kill that process or delete the staled lock"
          );
          if (validPid) {
            console.error(
              "Try run command: ",
              "`kill ",
              potential_pid,
              " || rm -f .bsb.lock`"
            );
          }
          process.exit(2);
        }
      }
    }
    watchers.push({ watcher: fs.watch(bsconfig, on_change), dir: bsconfig });
    build();
  }
}