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 bsc_exe = require("./scripts/bin_path").bsc_exe;
var rescript_exe = require("./scripts/bin_path").rescript_exe;
var bsconfig = "bsconfig.json";

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

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)

// If the project uses gentype and uses custom file extension
// via generatedFileExtension, ignore them in watch mode
var genTypeConfig = require(path.join(cwd, bsconfig)).gentypeconfig
if (genTypeConfig) {
  var genTypeFileExtension = genTypeConfig.generatedFileExtension
}

// 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(`Usage: rescript <options> <subcommand>

\`rescript\` is equivalent to \`rescript build\`

Options:
  -v, -version  display version number
  -h, -help     display help

Subcommands:
  init
  build
  clean
  format
  convert
  dump
  help

Run \`rescript <subcommand> -h\` for subcommand help. Examples:
  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() {
  if (is_building) {
    try {
      fs.unlinkSync(lockFileName);
    } catch (err) { }
    is_building = false;
  }
}

// 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.
function acquireBuild() {
  if (is_building) {
    return false;
  } else {
    try {
      fs.openSync(lockFileName, "wx", 0o664);
      is_building = true;
    } catch (err) {
      if (err.code === "EEXIST") {
        console.warn(lockFileName, "already exists, try later");
      } else console.log(err);
    }
    return is_building;
  }
}

if (
  maybe_subcommand !== undefined &&
  maybe_subcommand !== "build" &&
  maybe_subcommand !== "clean" &&
  maybe_subcommand !== "init" &&
  maybe_subcommand !== "info"
  // delegate to native
) {
  switch (maybe_subcommand) {
    case "format":
      require("./scripts/rescript_format.js").main(
        process.argv.slice(3),
        rescript_exe,
        bsc_exe
      );
      break;
    case "dump":
      require("./scripts/rescript_dump.js").main(
        process.argv.slice(3),
        rescript_exe,
        bsc_exe
      );
      break;
    case "dump":
      require("./scripts/rescript_dump.js").main(
        process.argv.slice(3),
        rescript_exe,
        bsc_exe
      );
      break;
    case "convert":
      // Todo
      require("./scripts/rescript_convert.js").main(
        process.argv.slice(3),
        rescript_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 = (delegate_args[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;
  if (acquireBuild()) {
    try {
      p = child_process.spawn(rescript_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));
      }
      releaseBuild();
      process.exit(2);
    }
    // The 'close' event will always emit after 'exit' was already emitted, or
    // 'error' if the child failed to spawn.
    p.on("close", (code, signal) => {
      releaseBuild();
      if (code !== 0) {
        process.exit(code);
      } else if (watch_mode) {
        in_watch_mode(useWebSocket);
      }
    });
  } else {
    console.warn(`Another build detected or staled lockfile ${lockFileName}`);
    // racing magic code
    process.exit(133);
  }
  /**
   *
   * @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);
      releaseBuild();
      process.exit(1);
    }
    function exitProcess() {
      releaseBuild();
      process.exit(0);
    }

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

    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") ||
        fileName.endsWith(genTypeFileExtension) ||
        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(0);
      } 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
    /**
     *
     * @param {number} depth
     * @returns
     */
    function build(depth) {
      if (reasons_to_rebuild.length === 0) {
        dlog("No need to rebuild");
        return;
      } else {
        dlog(`Rebuilding since ${reasons_to_rebuild}`);
      }
      if (acquireBuild()) {
        logStart();
        child_process
          .spawn(rescript_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();
      }
      // if acquiring lock failed, no need retry here
      // since build_finished_callback will try again
      // however this is no longer the case for multiple-process
      // it could fail due to other issues like .bsb.lock
      else {
        dlog(
          `Acquire lock failed, do the build later ${depth} : ${reasons_to_rebuild}`
        );
        var waitTime = Math.pow(2, depth) * 40;
        setTimeout(function () {
          var d = Math.min(depth + 1, 5);
          build(d);
        }, waitTime);
      }
    }
    /**
     *
     * @param {string} event
     * @param {string} reason
     */
    function on_change(event, reason) {
      var event_time = +Date.now();
      var time_diff = event_time - LAST_BUILD_START;
      var event_diff = event_time - LAST_FIRED_EVENT;
      dlog(`Since last build : ${time_diff} -- ${event_diff}`);
      if (time_diff < 5 || event_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(`\nEvent ${event} ${reason}`);
        LAST_FIRED_EVENT = event_time;
        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(0);
          }
        });
      }
    }

    watchers.push({ watcher: fs.watch(bsconfig, on_change), dir: bsconfig });
    build(0);
  }
}