@tellahq/rescript 10.1.0-alpha.1

package/rescript

@@ -0,0 +1,591 @@
+#!/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 bsConfigFile = path.join(cwd, bsconfig);
+var genTypeFileExtension = undefined;
+
+if (fs.existsSync(bsConfigFile)) {
+  var genTypeConfig = require(bsConfigFile).gentypeconfig
+  if (genTypeConfig) {
+    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 {
+      const fid = fs.openSync(lockFileName, "wx", 0o664);
+      fs.closeSync(fid);
+      is_building = true;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        console.warn(lockFileName, "already exists, try later");
+      } else console.log(err);
+    }
+    return is_building;
+  }
+}
+
+
+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);
+
+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 stale 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 = [];
+
+    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") ||
+        (genTypeFileExtension && 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);
+  }
+}

package/scripts/LICENSE.ml

@@ -0,0 +1,27 @@
+(* Copyright (C) 2015-2016 Bloomberg Finance L.P.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * In addition to the permissions granted to you by the LGPL, you may combine
+ * or link a "work that uses the Library" with a publicly distributed version
+ * of this file to produce a combined library or application, then distribute
+ * that combined work under the terms of your choosing, with no requirement
+ * to comply with the obligations normally placed on you by section 4 of the
+ * LGPL version 3 (or the corresponding section of a later version of the LGPL
+ * should you choose to use a 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 Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
+
+
+
+

package/scripts/bin_path.js

@@ -0,0 +1,38 @@
+//@ts-check
+
+var path = require("path");
+
+/**
+ * @type{string}
+ */
+var binDirName =
+  process.platform === "darwin" && process.arch === "arm64"
+    ? process.platform + process.arch
+    : process.platform;
+
+/**
+ *
+ * @type{string}
+ */
+var binAbsolutePath = path.join(__dirname, "..", binDirName);
+
+/**
+ * @type{string}
+ */
+var bsc_exe = path.join(binAbsolutePath, "bsc.exe");
+
+/**
+ * @type{string}
+ */
+var ninja_exe = path.join(binAbsolutePath, "ninja.exe");
+
+/**
+ * @type{string}
+ */
+var rescript_exe = path.join(binAbsolutePath, "rescript.exe");
+
+exports.dirName = binDirName;
+exports.absolutePath = binAbsolutePath;
+exports.bsc_exe = bsc_exe;
+exports.ninja_exe = ninja_exe;
+exports.rescript_exe = rescript_exe;

package/scripts/buckle_lto.js

@@ -0,0 +1,55 @@
+//@ts-check
+var fs = require("fs");
+
+var pairs = [
+  ["Config.bs_only", "true"],
+  ["Clflags.native_code", "false"],
+  ["Clflags.unsafe_string", "false"],
+  ["Clflags.record_event_when_debug", "false"],
+  ["Clflags.use_threads", "false"],
+  ["Clflags.use_vmthreads", "false"],
+  ["Clflags.no_implicit_current_dir", "true"],
+  ["Clflags.strict_formats", "true"],
+  ["Clflags.compile_only", "true"],
+];
+
+var regexp = RegExp(
+  `${pairs
+    .map(x => {
+      let result = [];
+      result.push("!" + x[0]);
+      let xs = x[0].split(".");
+      if (xs.length === 2 && xs[1]) {
+        result.push("!" + xs[1]);
+      }
+      return result;
+    })
+    .reduce((x, y) => x.concat(y))
+    .join("|")}`,
+  "g"
+);
+
+/**
+ *
+ * @param {string} s
+ */
+function transform(s) {
+  return s.replace(regexp, s => {
+    for (let [k, v] of pairs) {
+      if (s.includes(k.split(".")[1])) {
+        // "bs_only" instead of "Clflags.bs_only"
+        return v;
+      }
+    }
+    return s;
+  });
+}
+// transform('!Config.bs_only && Clflags.native && !Clflags.native')
+var file = process.argv[2];
+console.log(`POST-PROCESSING-FILE:`, file);
+fs.writeFileSync(
+  file,
+
+  transform(fs.readFileSync(file, { encoding: "utf8" })),
+  { encoding: "utf8" }
+);