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 bsconfig = "bsconfig.json";
var bsb_exe = path.join(__dirname, process.platform, "rescript.exe");

var LAST_SUCCESS_BUILD_STAMP = 0;
process.env.BSB_PROJECT_ROOT = process.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();
}
/**
 * @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 {*} 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;
var isInBuildMode = process_argv[2] === "build";

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}"`);
}

var delegate_args = process_argv.slice(2);
if (!isInBuildMode) {
  try {
    child_process.execFileSync(bsb_exe, delegate_args, {
      stdio: "inherit",
    });
  } catch (e) {
    if (e.code === "ENOENT") {
      // when rescript is not found
      console.log(String(e));
      process.exit(2);
    }
  }
  process.exit(0);
}

var watch_mode = delegate_args.includes("-w");
verbose = delegate_args.includes("-verbose");

try {
  child_process.execFileSync(bsb_exe, delegate_args, { stdio: "inherit" });
} catch (e) {
  if (e.code === "ENOENT") {
    // when bsb is actually not found
    console.error(String(e));
  }
  process.exit(2);
}

if (watch_mode) {
  var fs = require("fs");
  if (useWebSocket) {
    setUpWebSocket();
  }
  // for column one based error message
  var cwd = process.cwd();
  var lockFileName = path.join(cwd, ".bsb.lock");
  /**
   * @type {[string,string][]}
   */
  var reasons_to_rebuild = [];

  /**
   * 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 is_building = false;
  function releaseBuild() {
    is_building = false;
  }
  function acquireBuild() {
    if (is_building) {
      return false;
    } else {
      is_building = true;
      return true;
    }
  }
  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}`);
      }
      reasons_to_rebuild = [];
      var p = child_process.spawn(bsb_exe, [], {
        stdio: ["inherit", "inherit", "pipe"],
      });
      p.on("exit", build_finished_callback);
      p.stderr
        .setEncoding("utf8")
        // @ts-ignore
        .on("data", function (s) {
          error_output(s, "ninja: error");
        });
    }
  }
  /**
   *
   * @param {string} event
   * @param {string} reason
   */
  function on_change(event, reason) {
    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();
        }
      });
    }
  }
  function getWatchFiles(file) {
    if (fs.existsSync(file)) {
      return JSON.parse(fs.readFileSync(file, "utf8"));
    } else {
      return { dirs: [], generated: [] };
    }
  }

  /**
   *
   * @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();
}