@reventlessdev/reventless-gwt 1.0.0-alpha.115 → 1.0.0-alpha.116

package/src/PlatformScan.res.mjs

@@ -1,124 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Nodefs from "node:fs";
-import * as Nodepath from "node:path";
-import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Promises from "node:fs/promises";
-import * as ScanIgnore$ReventlessGwt from "./ScanIgnore.res.mjs";
-
-let localPlatformDep = "@reventlessdev/reventless-local";
-
-function matchPlatform(pkgJsonText, mainExists) {
-  if (!mainExists) {
-    return;
-  }
-  let json;
-  try {
-    json = JSON.parse(pkgJsonText);
-  } catch (exn) {
-    return;
-  }
-  let obj = Stdlib_JSON.Decode.object(json);
-  if (obj === undefined) {
-    return;
-  }
-  let match = obj["name"];
-  let name = typeof match === "string" ? match : "";
-  let depsHave = key => {
-    let deps = Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.object);
-    if (deps !== undefined) {
-      return Stdlib_Option.isSome(deps[localPlatformDep]);
-    } else {
-      return false;
-    }
-  };
-  let dependsOnLocal = depsHave("dependencies") || depsHave("devDependencies") || depsHave("optionalDependencies");
-  if (!dependsOnLocal) {
-    return;
-  }
-  let scripts = Stdlib_Option.flatMap(obj["scripts"], Stdlib_JSON.Decode.object);
-  let serveScript = scripts !== undefined ? (
-      Stdlib_Option.isSome(scripts["serve:memory"]) ? "serve:memory" : (
-          Stdlib_Option.isSome(scripts["serve"]) ? "serve" : undefined
-        )
-    ) : undefined;
-  return [
-    name,
-    serveScript
-  ];
-}
-
-function inspectDir(dir) {
-  let pkgJson = Nodepath.join(dir, "package.json");
-  let mainPath = Nodepath.join(Nodepath.join(dir, "src"), "Main.res.mjs");
-  if (!Nodefs.existsSync(pkgJson)) {
-    return;
-  }
-  let text;
-  try {
-    text = Nodefs.readFileSync(pkgJson, "utf8");
-  } catch (exn) {
-    text = "";
-  }
-  let match = matchPlatform(text, Nodefs.existsSync(mainPath));
-  if (match !== undefined) {
-    return {
-      name: match[0],
-      dir: dir,
-      mainPath: mainPath,
-      serveScript: match[1]
-    };
-  }
-}
-
-async function walk(dir, acc) {
-  let pkg = inspectDir(dir);
-  if (pkg !== undefined) {
-    acc.push(pkg);
-  } else {
-    let entries;
-    try {
-      entries = await Promises.readdir(dir, {
-        withFileTypes: true
-      });
-    } catch (exn) {
-      entries = [];
-    }
-    for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
-      let entry = entries[i];
-      if (entry.isDirectory() && !ScanIgnore$ReventlessGwt.shouldIgnore(entry.name)) {
-        await walk(Nodepath.join(dir, entry.name), acc);
-      }
-    }
-  }
-  return acc;
-}
-
-async function scan(roots) {
-  let seen = {};
-  let out = [];
-  for (let i = 0, i_finish = roots.length; i < i_finish; ++i) {
-    let found = await walk(roots[i], []);
-    found.forEach(pkg => {
-      let match = seen[pkg.dir];
-      if (match !== undefined) {
-        return;
-      } else {
-        seen[pkg.dir] = true;
-        out.push(pkg);
-        return;
-      }
-    });
-  }
-  return out;
-}
-
-export {
-  localPlatformDep,
-  matchPlatform,
-  inspectDir,
-  walk,
-  scan,
-}
-/* node:fs Not a pure module */

package/src/ProcessManager.res

@@ -1,135 +0,0 @@
-// Owns the `rescript build -w` watchers a watch session spawns — one per
-// package that owns tests (PackageScan), at most one per directory,
-// reference-counted by `dir`. Registered with Cancellation so SIGINT/SIGTERM
-// tears down every spawned watcher; never orphans a compiler.
-
-type managed = {
-  dir: string,
-  proc: ChildProcess.t,
-}
-
-let running: Dict.t<managed> = Dict.make()
-
-// Per-dir count of unexpected watcher exits, so a build-watcher that crashes on
-// startup (bad config, missing binary) is respawned a bounded number of times
-// rather than either freezing the build status forever or spinning in a tight
-// respawn loop.
-let restarts: Dict.t<int> = Dict.make()
-let maxRestarts = 3
-
-let isManaging = (dir: string): bool =>
-  switch running->Dict.get(dir) {
-  | Some(_) => true
-  | None => false
-  }
-
-// Spawn `pnpm run start` (the package's `rescript build -w`) in `pkg.dir`,
-// unless one is already managed there. `onStdout` receives each output line so
-// the caller can classify compiler markers (Phase 5).
-let rec spawnWatcher = (pkg: PackageScan.pkg, ~onStdout: (string, string) => unit): unit =>
-  switch running->Dict.get(pkg.dir) {
-  | Some(_) => ()
-  | None => {
-      let proc = ChildProcess.spawn("pnpm", ["run", "start"], ~cwd=pkg.dir)
-      ChildProcess.onStdoutLine(proc, line => onStdout(pkg.dir, line))
-      // stderr carries compiler/pnpm crash output; without this a watcher that
-      // dies on stderr was invisible until the caller's 120s watchdog.
-      ChildProcess.onStderrLine(proc, line => onStdout(pkg.dir, line))
-      // A spawn failure ("error") never reaches "close"; surface it as output.
-      ChildProcess.onError(proc, msg => onStdout(pkg.dir, msg))
-      // Detect an unexpected exit. We compare the stored proc identity: an
-      // intentional `stop` deletes the entry synchronously before "close" fires,
-      // so if we still own this exact proc, the watcher crashed — respawn it up
-      // to `maxRestarts` times so build status doesn't freeze.
-      ChildProcess.onClose(proc, _code =>
-        switch running->Dict.get(pkg.dir) {
-        | Some(m) if m.proc === proc =>
-          running->Dict.delete(pkg.dir)
-          let n = restarts->Dict.get(pkg.dir)->Option.getOr(0)
-          if n < maxRestarts {
-            restarts->Dict.set(pkg.dir, n + 1)
-            spawnWatcher(pkg, ~onStdout)
-          }
-        | _ => ()
-        }
-      )
-      running->Dict.set(pkg.dir, {dir: pkg.dir, proc})
-    }
-  }
-
-// Stop just the watcher managed for `dir` (if any), tearing down its process
-// group. Returns true when one was running — i.e. the caller *owned* this
-// package's build (vs. an adopted external watcher, which we can't stop).
-let stop = (dir: string): bool =>
-  switch running->Dict.get(dir) {
-  | Some(m) => {
-      ChildProcess.killTree(m.proc, "SIGTERM")
-      running->Dict.delete(dir)
-      true
-    }
-  | None => false
-  }
-
-// Force a full re-emit of `pkg` after a structural change — a module relocation
-// that incremental compilation can't detect, since it keys invalidation on
-// source + dependency-interface hashes, never on a dependency's filesystem
-// location (see plan Phase 12). Drives a deterministic one-shot `rescript clean`
-// → `rescript build` to completion (the `clean` is what forces every dependent
-// `.res.mjs` to be re-emitted against the new layout; the `build` is essential
-// even on the adopted path — an external watcher won't rebuild after a clean
-// without a fresh source change, so a bare clean would strand the package with
-// no outputs). If we *owned* the package's watcher we stop it first (no lock
-// contention) and respawn it afterward to resume incremental watching; on the
-// adopted path the developer's own watcher keeps running untouched. `onStdout`
-// streams the clean/build output (compiler markers) to the caller; `onDone`
-// fires once the build completes, gating the test re-run.
-let cleanRebuild = (
-  pkg: PackageScan.pkg,
-  ~onStdout: (string, string) => unit,
-  ~onDone: bool => unit,
-): unit => {
-  let wasManaged = stop(pkg.dir)
-  // `next` receives the step's exit code so the chain can tell a failed clean or
-  // build (non-zero / crash) from success — the previous shape discarded exit
-  // codes and always reported the rebuild as OK, masking compile failures.
-  let step = (cmd: string, args: array<string>, next: option<int> => unit): unit => {
-    let proc = ChildProcess.spawn(cmd, args, ~cwd=pkg.dir)
-    // "error" (spawn failure) and "close" can both fire; ensure the chain
-    // advances exactly once.
-    let settled = ref(false)
-    let settle = (code: option<int>) =>
-      if !settled.contents {
-        settled := true
-        next(code)
-      }
-    ChildProcess.onStdoutLine(proc, line => onStdout(pkg.dir, line))
-    ChildProcess.onStderrLine(proc, line => onStdout(pkg.dir, line))
-    ChildProcess.onError(proc, msg => {
-      onStdout(pkg.dir, msg)
-      settle(None)
-    })
-    ChildProcess.onClose(proc, code => settle(code))
-  }
-  step("pnpm", ["exec", "rescript", "clean"], _cleanCode =>
-    step("pnpm", ["exec", "rescript", "build"], buildCode => {
-      if wasManaged {
-        spawnWatcher(pkg, ~onStdout)
-      }
-      onDone(buildCode == Some(0))
-    })
-  )
-}
-
-// SIGTERM, not SIGINT: a POSIX shell sets background children to ignore SIGINT,
-// so SIGINT can leak a watcher; SIGTERM tears down the whole group reliably
-// (verified across foreground and background process-tree shapes).
-let killAll = (): unit => {
-  running
-  ->Dict.valuesToArray
-  ->Array.forEach(m => ChildProcess.killTree(m.proc, "SIGTERM"))
-  running
-  ->Dict.keysToArray
-  ->Array.forEach(k => running->Dict.delete(k))
-}
-
-let managedCount = (): int => running->Dict.keysToArray->Array.length

package/src/ProcessManager.res.mjs

@@ -1,119 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-import * as ChildProcess$ReventlessGwt from "./ChildProcess.res.mjs";
-
-let running = {};
-
-let restarts = {};
-
-function isManaging(dir) {
-  return running[dir] !== undefined;
-}
-
-function spawnWatcher(pkg, onStdout) {
-  let match = running[pkg.dir];
-  if (match !== undefined) {
-    return;
-  }
-  let proc = ChildProcess$ReventlessGwt.spawn("pnpm", [
-    "run",
-    "start"
-  ], pkg.dir, undefined);
-  ChildProcess$ReventlessGwt.onStdoutLine(proc, line => onStdout(pkg.dir, line));
-  ChildProcess$ReventlessGwt.onStderrLine(proc, line => onStdout(pkg.dir, line));
-  ChildProcess$ReventlessGwt.onError(proc, msg => onStdout(pkg.dir, msg));
-  ChildProcess$ReventlessGwt.onClose(proc, _code => {
-    let m = running[pkg.dir];
-    if (m === undefined) {
-      return;
-    }
-    if (m.proc !== proc) {
-      return;
-    }
-    Stdlib_Dict.$$delete(running, pkg.dir);
-    let n = Stdlib_Option.getOr(restarts[pkg.dir], 0);
-    if (n < 3) {
-      restarts[pkg.dir] = n + 1 | 0;
-      return spawnWatcher(pkg, onStdout);
-    }
-  });
-  running[pkg.dir] = {
-    dir: pkg.dir,
-    proc: proc
-  };
-}
-
-function stop(dir) {
-  let m = running[dir];
-  if (m !== undefined) {
-    ChildProcess$ReventlessGwt.killTree(m.proc, "SIGTERM");
-    Stdlib_Dict.$$delete(running, dir);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-function cleanRebuild(pkg, onStdout, onDone) {
-  let wasManaged = stop(pkg.dir);
-  let step = (cmd, args, next) => {
-    let proc = ChildProcess$ReventlessGwt.spawn(cmd, args, pkg.dir, undefined);
-    let settled = {
-      contents: false
-    };
-    let settle = code => {
-      if (!settled.contents) {
-        settled.contents = true;
-        return next(code);
-      }
-    };
-    ChildProcess$ReventlessGwt.onStdoutLine(proc, line => onStdout(pkg.dir, line));
-    ChildProcess$ReventlessGwt.onStderrLine(proc, line => onStdout(pkg.dir, line));
-    ChildProcess$ReventlessGwt.onError(proc, msg => {
-      onStdout(pkg.dir, msg);
-      settle(undefined);
-    });
-    ChildProcess$ReventlessGwt.onClose(proc, settle);
-  };
-  step("pnpm", [
-    "exec",
-    "rescript",
-    "clean"
-  ], _cleanCode => step("pnpm", [
-    "exec",
-    "rescript",
-    "build"
-  ], buildCode => {
-    if (wasManaged) {
-      spawnWatcher(pkg, onStdout);
-    }
-    onDone(Primitive_object.equal(buildCode, 0));
-  }));
-}
-
-function killAll() {
-  Object.values(running).forEach(m => ChildProcess$ReventlessGwt.killTree(m.proc, "SIGTERM"));
-  Object.keys(running).forEach(k => Stdlib_Dict.$$delete(running, k));
-}
-
-function managedCount() {
-  return Object.keys(running).length;
-}
-
-let maxRestarts = 3;
-
-export {
-  running,
-  restarts,
-  maxRestarts,
-  isManaging,
-  spawnWatcher,
-  stop,
-  cleanRebuild,
-  killAll,
-  managedCount,
-}
-/* ChildProcess-ReventlessGwt Not a pure module */

package/src/RunWorker.res

@@ -1,24 +0,0 @@
-// Worker entry for a single gwt watch re-run pass.
-//
-// Spawned by `Cli.runWatch` with the run `options` passed as `workerData`. Runs
-// exactly one `runOnce` in this fresh worker (fresh ESM registry → recompiled
-// implementation modules are re-imported, not served stale), emits its NDJSON to
-// stdout (piped to the parent), then exits so the imported graph is reclaimed.
-// The parent never reuses a worker — one per re-run.
-
-@val @module("node:worker_threads") external workerData: Cli.options = "workerData"
-@val external processExit: int => unit = "process.exit"
-
-let () = {
-  let _ =
-    Cli.runOnce(workerData)
-    ->Promise.then(code => {
-      processExit(code)
-      Promise.resolve()
-    })
-    ->Promise.catch(e => {
-      Console.error2("gwt run worker failed:", e)
-      processExit(1)
-      Promise.resolve()
-    })
-}

package/src/RunWorker.res.mjs

@@ -1,16 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
-import * as Cli$ReventlessGwt from "./Cli.res.mjs";
-import * as Nodeworker_threads from "node:worker_threads";
-
-Stdlib_Promise.$$catch(Cli$ReventlessGwt.runOnce(Nodeworker_threads.workerData).then(code => {
-  process.exit(code);
-  return Promise.resolve();
-}), e => {
-  console.error("gwt run worker failed:", e);
-  process.exit(1);
-  return Promise.resolve();
-});
-
-/*  Not a pure module */

package/src/RunnerTypes.res

@@ -1,68 +0,0 @@
-// Shared data types between the runner loop and formatters.
-
-type testStatus = Pass | Fail | Skip
-
-type testResult = {
-  id: string,
-  name: string,
-  describePath: array<string>,
-  status: testStatus,
-  durationMs: float,
-  location: option<Collector.location>,
-  slice: option<string>,
-  mismatch: option<Outcome.mismatch>,
-  skipReason: option<string>,
-}
-
-type fileResult = {
-  path: string,
-  tests: array<testResult>,
-}
-
-type summary = {
-  total: int,
-  passed: int,
-  failed: int,
-  skipped: int,
-  files: int,
-  durationMs: float,
-  startedAt: string,
-}
-
-type runResult = {
-  summary: summary,
-  files: array<fileResult>,
-}
-
-let statusString = (s: testStatus) =>
-  switch s {
-  | Pass => "pass"
-  | Fail => "fail"
-  | Skip => "skip"
-  }
-
-let summaryOf = (files: array<fileResult>, durationMs: float, startedAt: string): summary => {
-  let total = ref(0)
-  let passed = ref(0)
-  let failed = ref(0)
-  let skipped = ref(0)
-  files->Array.forEach(f =>
-    f.tests->Array.forEach(t => {
-      total := total.contents + 1
-      switch t.status {
-      | Pass => passed := passed.contents + 1
-      | Fail => failed := failed.contents + 1
-      | Skip => skipped := skipped.contents + 1
-      }
-    })
-  )
-  {
-    total: total.contents,
-    passed: passed.contents,
-    failed: failed.contents,
-    skipped: skipped.contents,
-    files: files->Array.length,
-    durationMs,
-    startedAt,
-  }
-}

package/src/RunnerTypes.res.mjs

@@ -1,60 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-function statusString(s) {
-  switch (s) {
-    case "Pass" :
-      return "pass";
-    case "Fail" :
-      return "fail";
-    case "Skip" :
-      return "skip";
-  }
-}
-
-function summaryOf(files, durationMs, startedAt) {
-  let total = {
-    contents: 0
-  };
-  let passed = {
-    contents: 0
-  };
-  let failed = {
-    contents: 0
-  };
-  let skipped = {
-    contents: 0
-  };
-  files.forEach(f => {
-    f.tests.forEach(t => {
-      total.contents = total.contents + 1 | 0;
-      let match = t.status;
-      switch (match) {
-        case "Pass" :
-          passed.contents = passed.contents + 1 | 0;
-          return;
-        case "Fail" :
-          failed.contents = failed.contents + 1 | 0;
-          return;
-        case "Skip" :
-          skipped.contents = skipped.contents + 1 | 0;
-          return;
-      }
-    });
-  });
-  return {
-    total: total.contents,
-    passed: passed.contents,
-    failed: failed.contents,
-    skipped: skipped.contents,
-    files: files.length,
-    durationMs: durationMs,
-    startedAt: startedAt
-  };
-}
-
-export {
-  statusString,
-  summaryOf,
-}
-/* No side effect */

package/src/ScanIgnore.res

@@ -1,11 +0,0 @@
-// Single source for the directory names pruned from every monorepo scan — test
-// discovery, component scan, platform scan — and the equivalent chokidar globs
-// for the watch. Previously duplicated verbatim across the three walkers and,
-// divergently, as inline globs in `Watch`; that drift once let `dist/` writes
-// drive a re-run loop.
-let names = ["node_modules", ".git", "dist", "lib", ".history"]
-
-let shouldIgnore = (name: string): bool => names->Array.includes(name)
-
-// chokidar-style globs derived from the same list (the watch's ignore set).
-let globs = names->Array.map(n => "**/" ++ n ++ "/**")

package/src/ScanIgnore.res.mjs

@@ -1,23 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let names = [
-  "node_modules",
-  ".git",
-  "dist",
-  "lib",
-  ".history"
-];
-
-function shouldIgnore(name) {
-  return names.includes(name);
-}
-
-let globs = names.map(n => "**/" + n + "/**");
-
-export {
-  names,
-  shouldIgnore,
-  globs,
-}
-/* globs Not a pure module */

package/src/Watch.res

@@ -1,102 +0,0 @@
-// Wraps `chokidar` for the `reventless-gwt watch` and `reventless-gwt run
-// --watch` modes. Emits one callback per file change event (creates, edits,
-// deletes) after a small debounce window so rapid editor saves don't trigger
-// overlapping runs.
-
-type watcher
-type opts = {
-  ignoreInitial: bool,
-  ignored: array<string>,
-}
-
-// The kind of filesystem change, threaded through so the consumer can tell a
-// *structural* change (a source file appearing/disappearing — the move/delete
-// half of a relocation) from a plain edit. Phase 12 keys its clean-rebuild on
-// an `Unlink` of a `.res` source.
-type event = Add | Change | Unlink
-
-@module("chokidar") external watch: (array<string>, opts) => watcher = "watch"
-@send external on: (watcher, string, string => unit) => watcher = "on"
-@send external close: watcher => promise<unit> = "close"
-
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-@val external clearTimeout: float => unit = "clearTimeout"
-
-// True when an event is the *structural* signal Phase 12 acts on: a source
-// `.res` file leaving a directory (the move/delete half of a relocation).
-// Generated `.res.mjs` outputs end in `.mjs`, so they never match — which is
-// also what keeps a `rescript clean` (it deletes those outputs) from
-// re-triggering the clean-rebuild it just ran.
-let isStructuralSource = (event: event, path: string): bool =>
-  event == Unlink && String.endsWith(path, ".res")
-
-// Coalesce a burst of chokidar events into a single debounce window, then emit.
-// A window may span *multiple* packages — a branch switch or a multi-package
-// refactor emits `.res` unlinks under several package roots at once. The old
-// shape kept only one "best" path, so it clean-rebuilt just one package and
-// left the others with stale `.res.mjs`. Instead accumulate the *set* of
-// distinct structural source paths and emit one `Unlink` callback per path
-// (the consumer maps each to its owning package). If the window held no
-// structural signal, emit a single representative event so the consumer does a
-// plain re-run.
-let debounce = (wait: int, fn: (event, string) => unit) => {
-  let pending: ref<option<float>> = ref(None)
-  let structural: ref<array<string>> = ref([])
-  let sawOther = ref(false)
-  let otherEvent = ref(Change)
-  let otherPath = ref("")
-  (event, path) => {
-    if isStructuralSource(event, path) {
-      if !(structural.contents->Array.includes(path)) {
-        structural := Array.concat(structural.contents, [path])
-      }
-    } else {
-      sawOther := true
-      otherEvent := event
-      otherPath := path
-    }
-    switch pending.contents {
-    | Some(t) => clearTimeout(t)
-    | None => ()
-    }
-    pending :=
-      Some(
-        setTimeout(() => {
-          pending := None
-          let paths = structural.contents
-          let other = sawOther.contents
-          let oe = otherEvent.contents
-          let op = otherPath.contents
-          structural := []
-          sawOther := false
-          otherEvent := Change
-          otherPath := ""
-          if paths->Array.length > 0 {
-            // One rebuild per distinct owning package; a plain edit alongside
-            // is covered by each structural rebuild's own re-run.
-            paths->Array.forEach(p => fn(Unlink, p))
-          } else if other {
-            fn(oe, op)
-          }
-        }, wait),
-      )
-  }
-}
-
-let start = (roots: array<string>, onChange: (event, string) => unit): watcher => {
-  let w = watch(
-    roots,
-    {
-      ignoreInitial: true,
-      // Shared with the scanners via `ScanIgnore` — writes under `dist/` or
-      // `.history/` are build/editor output, not source, and a `dist/` write
-      // could otherwise drive a re-run loop.
-      ignored: ScanIgnore.globs,
-    },
-  )
-  let debounced = debounce(120, onChange)
-  w
-  ->on("add", p => debounced(Add, p))
-  ->on("change", p => debounced(Change, p))
-  ->on("unlink", p => debounced(Unlink, p))
-}