@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/BuildClassifier.res.mjs

@@ -0,0 +1,136 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let stripAnsi = (s => s.replace(/\x1b\[[0-9;]*m/g, ""));
+
+function isStartLine(l) {
+  if (l.startsWith("Parsed ")) {
+    return l.endsWith("source files");
+  } else {
+    return false;
+  }
+}
+
+function isFinishLine(l) {
+  if (l.includes("Finished")) {
+    return l.includes("compilation");
+  } else {
+    return false;
+  }
+}
+
+function isErrorMarker(l) {
+  if (l.includes("We've found a bug for you!") || l.includes("Syntax error")) {
+    return true;
+  } else if (l.startsWith("Found ")) {
+    return l.includes("error");
+  } else {
+    return false;
+  }
+}
+
+function make(watchdogMsOpt, cb) {
+  let watchdogMs = watchdogMsOpt !== undefined ? watchdogMsOpt : 120000;
+  let compiling = {
+    contents: false
+  };
+  let hasError = {
+    contents: false
+  };
+  let startTime = {
+    contents: 0.0
+  };
+  let buffer = {
+    contents: []
+  };
+  let timer = {
+    contents: undefined
+  };
+  let watchdog = {
+    contents: undefined
+  };
+  let clearTimer = () => {
+    let t = timer.contents;
+    if (t !== undefined) {
+      clearTimeout(t);
+      timer.contents = undefined;
+      return;
+    }
+  };
+  let clearWatchdog = () => {
+    let t = watchdog.contents;
+    if (t !== undefined) {
+      clearTimeout(t);
+      watchdog.contents = undefined;
+      return;
+    }
+  };
+  let reset = () => {
+    compiling.contents = false;
+    hasError.contents = false;
+    buffer.contents = [];
+  };
+  let settle = () => {
+    if (!(compiling.contents && hasError.contents)) {
+      return;
+    }
+    let msg = buffer.contents.slice(0, 20).join("\n");
+    clearWatchdog();
+    cb.onFail(msg);
+    reset();
+  };
+  let arm = () => {
+    clearTimer();
+    timer.contents = setTimeout(settle, 400);
+  };
+  let armWatchdog = () => {
+    clearWatchdog();
+    watchdog.contents = setTimeout(() => {
+      if (compiling.contents) {
+        clearTimer();
+        cb.onFail("build watchdog: no completion within " + (watchdogMs / 1000 | 0).toString() + "s");
+        return reset();
+      }
+    }, watchdogMs);
+  };
+  return line => {
+    let l = stripAnsi(line).trim();
+    if (isStartLine(l)) {
+      if (!compiling.contents) {
+        cb.onStart();
+      }
+      compiling.contents = true;
+      hasError.contents = false;
+      buffer.contents = [];
+      startTime.contents = performance.now();
+      arm();
+      return armWatchdog();
+    } else if (isFinishLine(l)) {
+      clearTimer();
+      clearWatchdog();
+      if (compiling.contents) {
+        cb.onOk(performance.now() - startTime.contents);
+        return reset();
+      } else {
+        return;
+      }
+    } else {
+      if (l.length > 0) {
+        buffer.contents = buffer.contents.concat([l]);
+      }
+      if (isErrorMarker(l)) {
+        hasError.contents = true;
+      }
+      return arm();
+    }
+  };
+}
+
+export {
+  stripAnsi,
+  isStartLine,
+  isFinishLine,
+  isErrorMarker,
+  make,
+}
+/* No side effect */

package/src/Cancellation.res

@@ -0,0 +1,31 @@
+// SIGINT / SIGTERM trap. Sets a module-level flag that the main loop
+// polls between tests. The VS Code and JSON streaming formatters flush a
+// `runEnd` event with the skipped remainder before the process exits.
+
+type process
+@val external process: process = "process"
+@send external onSignal: (process, string, unit => unit) => unit = "on"
+@send external exit: (process, int) => unit = "exit"
+
+let cancelled = ref(false)
+let handlers: ref<array<unit => unit>> = ref([])
+
+let isCancelled = () => cancelled.contents
+
+let onCancel = (handler: unit => unit) =>
+  handlers := Array.concat(handlers.contents, [handler])
+
+let install = () => {
+  let handler = () => {
+    if !cancelled.contents {
+      cancelled := true
+      handlers.contents->Array.forEach(h =>
+        try h() catch {
+        | _ => ()
+        }
+      )
+    }
+  }
+  process->onSignal("SIGINT", handler)
+  process->onSignal("SIGTERM", handler)
+}

package/src/Cancellation.res.mjs

@@ -0,0 +1,45 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let cancelled = {
+  contents: false
+};
+
+let handlers = {
+  contents: []
+};
+
+function isCancelled() {
+  return cancelled.contents;
+}
+
+function onCancel(handler) {
+  handlers.contents = handlers.contents.concat([handler]);
+}
+
+function install() {
+  let handler = () => {
+    if (!cancelled.contents) {
+      cancelled.contents = true;
+      handlers.contents.forEach(h => {
+        try {
+          return h();
+        } catch (exn) {
+          return;
+        }
+      });
+      return;
+    }
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}
+
+export {
+  cancelled,
+  handlers,
+  isCancelled,
+  onCancel,
+  install,
+}
+/* No side effect */

package/src/ChildProcess.res

@@ -0,0 +1,84 @@
+// Minimal `node:child_process` binding for the watch-mode build manager. The
+// only consumer is ProcessManager, which spawns one `pnpm run start`
+// (`rescript build -w`) per package. Children are spawned **detached** so each
+// gets its own process group; killing the negative pid then tears down the whole
+// tree (pnpm + the rescript watcher it spawns) — no orphaned compilers.
+
+type t
+type stream
+
+type spawnOptions = {
+  cwd: string,
+  detached: bool,
+  env: Dict.t<string>,
+}
+
+@module("node:child_process")
+external _spawn: (string, array<string>, spawnOptions) => t = "spawn"
+
+@val external _processEnv: Dict.t<string> = "process.env"
+
+// Merge the current process env with optional overrides into a fresh dict — node's
+// `spawn` replaces the whole env, so callers that pass `~env` still inherit PATH etc.
+let mergeEnv = (overrides: option<Dict.t<string>>): Dict.t<string> => {
+  let m = Dict.make()
+  _processEnv->Dict.toArray->Array.forEach(((k, v)) => m->Dict.set(k, v))
+  switch overrides {
+  | Some(o) => o->Dict.toArray->Array.forEach(((k, v)) => m->Dict.set(k, v))
+  | None => ()
+  }
+  m
+}
+
+@get external _pid: t => Nullable.t<int> = "pid"
+@get external _stdout: t => stream = "stdout"
+@get external _stderr: t => stream = "stderr"
+@send external _streamSetEncoding: (stream, string) => unit = "setEncoding"
+@send external _streamOn: (stream, string, string => unit) => unit = "on"
+@send external _procOnClose: (t, string, Nullable.t<int> => unit) => unit = "on"
+@send external _kill: (t, string) => bool = "kill"
+@val external _processKill: (int, string) => unit = "process.kill"
+
+let spawn = (cmd: string, args: array<string>, ~cwd: string, ~env: option<Dict.t<string>>=?): t =>
+  _spawn(cmd, args, {cwd, detached: true, env: mergeEnv(env)})
+
+let pid = (proc: t): option<int> => proc->_pid->Nullable.toOption
+
+// Subscribe to a stream line-by-line (stdout or stderr), buffering partial
+// chunks. Used to classify ReScript compiler markers in Phase 5.
+let onLines = (s: stream, cb: string => unit): unit => {
+  _streamSetEncoding(s, "utf8")
+  let buf = ref("")
+  _streamOn(s, "data", chunk => {
+    buf := buf.contents ++ chunk
+    let rec drain = () =>
+      switch String.indexOf(buf.contents, "\n") {
+      | -1 => ()
+      | idx => {
+          let line = String.slice(buf.contents, ~start=0, ~end=idx)
+          buf := String.slice(buf.contents, ~start=idx + 1, ~end=String.length(buf.contents))
+          cb(line)
+          drain()
+        }
+      }
+    drain()
+  })
+}
+
+let onStdoutLine = (proc: t, cb: string => unit): unit => onLines(proc->_stdout, cb)
+let onStderrLine = (proc: t, cb: string => unit): unit => onLines(proc->_stderr, cb)
+let onClose = (proc: t, cb: option<int> => unit): unit =>
+  _procOnClose(proc, "close", code => cb(code->Nullable.toOption))
+
+// Kill the child's whole process group (negative pid) so the rescript watcher
+// pnpm spawned dies too. Falls back to a direct kill if the pid is gone.
+let killTree = (proc: t, signal: string): unit =>
+  switch proc->pid {
+  | Some(p) =>
+    try {
+      _processKill(-p, signal)
+    } catch {
+    | _ => ignore(proc->_kill(signal))
+    }
+  | None => ignore(proc->_kill(signal))
+  }

package/src/ChildProcess.res.mjs

@@ -0,0 +1,92 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Nodechild_process from "node:child_process";
+
+function mergeEnv(overrides) {
+  let m = {};
+  Object.entries(process.env).forEach(param => {
+    m[param[0]] = param[1];
+  });
+  if (overrides !== undefined) {
+    Object.entries(overrides).forEach(param => {
+      m[param[0]] = param[1];
+    });
+  }
+  return m;
+}
+
+function spawn(cmd, args, cwd, env) {
+  return Nodechild_process.spawn(cmd, args, {
+    cwd: cwd,
+    detached: true,
+    env: mergeEnv(env)
+  });
+}
+
+function pid(proc) {
+  return Primitive_option.fromNullable(proc.pid);
+}
+
+function onLines(s, cb) {
+  s.setEncoding("utf8");
+  let buf = {
+    contents: ""
+  };
+  s.on("data", chunk => {
+    buf.contents = buf.contents + chunk;
+    let drain = () => {
+      while (true) {
+        let idx = buf.contents.indexOf("\n");
+        if (idx === -1) {
+          return;
+        }
+        let line = buf.contents.slice(0, idx);
+        buf.contents = buf.contents.slice(idx + 1 | 0, buf.contents.length);
+        cb(line);
+        continue;
+      };
+    };
+    drain();
+  });
+}
+
+function onStdoutLine(proc, cb) {
+  onLines(proc.stdout, cb);
+}
+
+function onStderrLine(proc, cb) {
+  onLines(proc.stderr, cb);
+}
+
+function onClose(proc, cb) {
+  proc.on("close", code => cb((code == null) ? undefined : Primitive_option.some(code)));
+}
+
+function killTree(proc, signal) {
+  let p = Primitive_option.fromNullable(proc.pid);
+  if (p !== undefined) {
+    try {
+      process.kill(-p | 0, signal);
+      return;
+    } catch (exn) {
+      proc.kill(signal);
+      return;
+    }
+  } else {
+    proc.kill(signal);
+    return;
+  }
+}
+
+export {
+  mergeEnv,
+  spawn,
+  pid,
+  onLines,
+  onStdoutLine,
+  onStderrLine,
+  onClose,
+  killTree,
+}
+/* node:child_process Not a pure module */