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

package/src/ComponentScan.res.mjs

@@ -1,105 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Nodefs from "node:fs";
-import * as Nodepath from "node:path";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Promises from "node:fs/promises";
-import * as ComponentMeta$ReventlessGwt from "./ComponentMeta.res.mjs";
-
-let ignoreNames = [
-  "node_modules",
-  ".git",
-  "dist",
-  "lib",
-  ".history"
-];
-
-function shouldIgnore(name) {
-  return ignoreNames.includes(name);
-}
-
-let gwtIgnoreFile = ".gwtignore";
-
-function isPruned(entries) {
-  return entries.some(e => e.name === gwtIgnoreFile);
-}
-
-function isSrcResFile(name) {
-  return name.endsWith(".res");
-}
-
-async function walk(dir, acc) {
-  let entries;
-  try {
-    entries = await Promises.readdir(dir, {
-      withFileTypes: true
-    });
-  } catch (exn) {
-    entries = [];
-  }
-  if (isPruned(entries)) {
-    return acc;
-  }
-  let found = acc;
-  for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
-    let entry = entries[i];
-    if (!ignoreNames.includes(entry.name)) {
-      let full = Nodepath.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        let nested = await walk(full, []);
-        found = found.concat(nested);
-      } else if (entry.isFile() && entry.name.endsWith(".res")) {
-        found = found.concat([full]);
-      }
-    }
-  }
-  return found;
-}
-
-async function scan(pkgDirs) {
-  let order = [];
-  let filesByKey = {};
-  for (let i = 0, i_finish = pkgDirs.length; i < i_finish; ++i) {
-    let dir = pkgDirs[i];
-    let srcDir = Nodepath.join(dir, "src");
-    if (Nodefs.existsSync(srcDir)) {
-      let files = await walk(srcDir, []);
-      files.forEach(file => {
-        let c = ComponentMeta$ReventlessGwt.componentOfSrcFile(file);
-        if (c === undefined) {
-          return;
-        }
-        let key = dir + "::" + c.kind + "::" + c.name;
-        let existing = filesByKey[key];
-        if (existing !== undefined) {
-          filesByKey[key] = existing.concat([file]);
-        } else {
-          filesByKey[key] = [file];
-          order.push({
-            dir: dir,
-            kind: c.kind,
-            name: c.name,
-            key: key
-          });
-        }
-      });
-    }
-  }
-  return order.map(o => ({
-    dir: o.dir,
-    kind: o.kind,
-    name: o.name,
-    files: Stdlib_Option.getOr(filesByKey[o.key], [])
-  }));
-}
-
-export {
-  ignoreNames,
-  shouldIgnore,
-  gwtIgnoreFile,
-  isPruned,
-  isSrcResFile,
-  walk,
-  scan,
-}
-/* node:fs Not a pure module */

package/src/Discovery.res

@@ -1,105 +0,0 @@
-// Walks a directory tree and returns absolute paths of compiled GWT test
-// files (`*_GWT.res.mjs` plus `*GwtTest.res.mjs` — the two shapes used in
-// the monorepo today). Respects a minimal ignore set (`node_modules`,
-// `lib`, `.git`, `dist`, `.history`). Pruning `lib` covers compiled
-// `lib/bs` / `lib/ocaml` outputs. Full `.gitignore` parsing is out of scope;
-// the ignore set is enough to make a bare cwd scan (the auto-discovery
-// default) cheap and correct across a multi-package workspace.
-
-type dirent = {
-  name: string,
-  @as("isDirectory") _isDirectory: unit => bool,
-  @as("isFile") _isFile: unit => bool,
-}
-
-type readdirOpts = {withFileTypes: bool}
-
-@module("node:fs/promises")
-external _readdir: (string, readdirOpts) => promise<array<dirent>> = "readdir"
-
-type stats = {
-  @as("isDirectory") _isDirectory: unit => bool,
-  @as("isFile") _isFile: unit => bool,
-}
-
-@module("node:fs/promises") external _stat: string => promise<stats> = "stat"
-
-@module("node:path") external join: (string, string) => string = "join"
-@module("node:path") external isAbsolute: string => bool = "isAbsolute"
-@module("node:path") external resolve: string => string = "resolve"
-
-let ignoreNames = ["node_modules", ".git", "dist", "lib", ".history"]
-let shouldIgnore = (name: string) => Array.includes(ignoreNames, name)
-
-// A directory carrying this sentinel file — and its whole subtree — is pruned
-// from discovery. Unlike the `ignoreNames` dir-name list, this is filesystem
-// state, so it excludes generated/vendored trees (e.g. codegen golden fixtures)
-// even when compiled `*_GWT.res.mjs` are present on disk.
-let gwtIgnoreFile = ".gwtignore"
-let isPruned = (entries: array<dirent>) => entries->Array.some(e => e.name == gwtIgnoreFile)
-
-let isGwtTestFile = (name: string) =>
-  String.endsWith(name, "_GWT.res.mjs") ||
-  String.endsWith(name, "GwtTest.res.mjs") ||
-  String.endsWith(name, "Gwt.res.mjs")
-
-// Depth-first, pushing into a shared accumulator instead of rebuilding it with
-// `Array.concat` per entry (which was O(n²) over a large tree). The traversal
-// order is unchanged: files and nested subtree results still land in on-disk
-// entry order.
-let rec walk = async (dir: string, acc: array<string>): unit => {
-  let entries = try {
-    await _readdir(dir, {withFileTypes: true})
-  } catch {
-  | _ => []
-  }
-  if isPruned(entries) {
-    ()
-  } else {
-    for i in 0 to entries->Array.length - 1 {
-      let entry = entries->Array.getUnsafe(i)
-      if !shouldIgnore(entry.name) {
-        let full = join(dir, entry.name)
-        if entry._isDirectory() {
-          await walk(full, acc)
-        } else if entry._isFile() && isGwtTestFile(entry.name) {
-          acc->Array.push(full)
-        }
-      }
-    }
-  }
-}
-
-// Returns absolute paths of `*GWT*.res.mjs` test files reachable from the
-// supplied roots. A root may be a directory or a single file.
-let discover = async (roots: array<string>): array<string> => {
-  let found = []
-  for i in 0 to roots->Array.length - 1 {
-    let root = roots->Array.getUnsafe(i)
-    let absolute = isAbsolute(root) ? root : resolve(root)
-    let isDir = try {
-      let s = await _stat(absolute)
-      s._isDirectory()
-    } catch {
-    | _ => false
-    }
-    if isDir {
-      await walk(absolute, found)
-    } else if isGwtTestFile(absolute) {
-      found->Array.push(absolute)
-    }
-  }
-  // Deduplicate (if roots overlap).
-  let seen = Dict.make()
-  let unique = []
-  found->Array.forEach(path =>
-    switch seen->Dict.get(path) {
-    | Some(_) => ()
-    | None => {
-        seen->Dict.set(path, true)
-        unique->Array.push(path)
-      }
-    }
-  )
-  unique
-}

package/src/Discovery.res.mjs

@@ -1,99 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Nodepath from "node:path";
-import * as Promises from "node:fs/promises";
-
-let ignoreNames = [
-  "node_modules",
-  ".git",
-  "dist",
-  "lib",
-  ".history"
-];
-
-function shouldIgnore(name) {
-  return ignoreNames.includes(name);
-}
-
-let gwtIgnoreFile = ".gwtignore";
-
-function isPruned(entries) {
-  return entries.some(e => e.name === gwtIgnoreFile);
-}
-
-function isGwtTestFile(name) {
-  if (name.endsWith("_GWT.res.mjs") || name.endsWith("GwtTest.res.mjs")) {
-    return true;
-  } else {
-    return name.endsWith("Gwt.res.mjs");
-  }
-}
-
-async function walk(dir, acc) {
-  let entries;
-  try {
-    entries = await Promises.readdir(dir, {
-      withFileTypes: true
-    });
-  } catch (exn) {
-    entries = [];
-  }
-  if (isPruned(entries)) {
-    return;
-  }
-  for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
-    let entry = entries[i];
-    if (!ignoreNames.includes(entry.name)) {
-      let full = Nodepath.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(full, acc);
-      } else if (entry.isFile() && isGwtTestFile(entry.name)) {
-        acc.push(full);
-      }
-    }
-  }
-}
-
-async function discover(roots) {
-  let found = [];
-  for (let i = 0, i_finish = roots.length; i < i_finish; ++i) {
-    let root = roots[i];
-    let absolute = Nodepath.isAbsolute(root) ? root : Nodepath.resolve(root);
-    let isDir;
-    try {
-      let s = await Promises.stat(absolute);
-      isDir = s.isDirectory();
-    } catch (exn) {
-      isDir = false;
-    }
-    if (isDir) {
-      await walk(absolute, found);
-    } else if (isGwtTestFile(absolute)) {
-      found.push(absolute);
-    }
-  }
-  let seen = {};
-  let unique = [];
-  found.forEach(path => {
-    let match = seen[path];
-    if (match !== undefined) {
-      return;
-    } else {
-      seen[path] = true;
-      unique.push(path);
-      return;
-    }
-  });
-  return unique;
-}
-
-export {
-  ignoreNames,
-  shouldIgnore,
-  gwtIgnoreFile,
-  isPruned,
-  isGwtTestFile,
-  walk,
-  discover,
-}
-/* node:path Not a pure module */

package/src/DomainDeadCode.res

@@ -1,98 +0,0 @@
-// Domain-level dead-code analysis (Phase 5). Pure reflection over the loaded
-// pluginStructures (LocalHost.loadGraph): finds produced event
-// types that no component consumes — the event-sourcing counterpart to reactive
-// dead code, the domain layer the language LSP cannot see.
-//
-// An event is reachable when ANY of these hold:
-//   1. Some component lists it in `consumedEventTypes` — the DCB-style link used by
-//      state-view slices, automation slices, outbound translations, and aggregate /
-//      state-change-slice consistency reads. Scanned across ALL plugins, so a
-//      cross-plugin consumer clears it.
-//   2. The producing write-side has a non-empty `linkedViews`. Classic aggregate →
-//      read-model projections express the link on the PRODUCER side (the read model's
-//      `consumedEventTypes` is empty; it projects the aggregate's whole stream). This
-//      is event-opaque, so a write-side with at least one linked view is treated as
-//      fully consumed — see the precision caveat below.
-// A produced event matched by neither of these is reported as an orphan, anchored on
-// the producing write-side declaration.
-//
-// Precision caveat: because classic read models carry no per-event consumption, rule
-// (2) is conservative — a write-side with a linked view is never flagged, even if a
-// specific event it produces is projected by nothing. This avoids false positives at
-// the cost of missing per-event orphans inside an otherwise-projected aggregate. DCB
-// consumers (rule 1) keep full per-event precision.
-//
-// Scope (v1): orphan produced events only. "Extension points with zero extensions"
-// and "read models nothing resolves against" need data `pluginStructure` does not
-// carry (the EP declaration list / the id-resolver table) — deferred.
-
-// Finding kinds are the typed protocol vocabulary — constructing the variant here
-// (not a string literal) means a typo or rename is a compile error, and the emitter
-// forwards findings without conversion.
-module P = ReventlessDomainProtocol.Protocol
-
-type finding = {
-  kind: P.deadCodeKind,
-  pluginName: string, // plugin owning the producer
-  componentName: string, // the producing aggregate / state-change slice
-  detail: string, // the orphaned event type
-}
-
-let analyze = (
-  ~structures: array<(string, Reventless.Plugin.pluginStructure)>,
-): array<finding> => {
-  // Every event type consumed anywhere becomes a key in `consumed`.
-  let consumed = Dict.make()
-  let mark = (evt: string) => consumed->Dict.set(evt, true)
-  structures->Array.forEach(((_, s)) => {
-    s.readModels->Array.forEach((q: Reventless.Plugin.queryableDef) =>
-      q.consumedEventTypes->Array.forEach(mark)
-    )
-    s.stateViewSlices->Array.forEach((q: Reventless.Plugin.queryableDef) =>
-      q.consumedEventTypes->Array.forEach(mark)
-    )
-    s.aggregates->Array.forEach((w: Reventless.Plugin.writableDef) =>
-      w.consumedEventTypes->Array.forEach(mark)
-    )
-    s.stateChangeSlices->Array.forEach((w: Reventless.Plugin.writableDef) =>
-      w.consumedEventTypes->Array.forEach(mark)
-    )
-    s.automationSlices->Array.forEach((a: Reventless.Plugin.automationSliceDef) =>
-      a.consumedEventTypes->Array.forEach(mark)
-    )
-    s.outboundTranslationSlices->Array.forEach((o: Reventless.Plugin.outboundTranslationSliceDef) =>
-      o.consumedEventTypes->Array.forEach(mark)
-    )
-    s.extensions->Array.forEach((e: Reventless.Plugin.extensionDef) =>
-      e.eventTypes->Array.forEach(mark)
-    )
-  })
-
-  // Produced events with no consumer, reported per producing write-side. A write-side
-  // with a linked view is treated as fully consumed (rule 2 above).
-  let findings = []
-  let scanProducers = (pluginName, writables: array<Reventless.Plugin.writableDef>) =>
-    writables->Array.forEach(w =>
-      if w.linkedViews->Array.length > 0 {
-        ()
-      } else {
-        w.producedEventTypes->Array.forEach(evt =>
-          switch consumed->Dict.get(evt) {
-          | Some(_) => ()
-          | None =>
-            findings->Array.push({
-              kind: OrphanEvent,
-              pluginName,
-              componentName: w.name,
-              detail: evt,
-            })
-          }
-        )
-      }
-    )
-  structures->Array.forEach(((pluginName, s)) => {
-    scanProducers(pluginName, s.aggregates)
-    scanProducers(pluginName, s.stateChangeSlices)
-  })
-  findings
-}

package/src/DomainDeadCode.res.mjs

@@ -1,72 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-function analyze(structures) {
-  let consumed = {};
-  let mark = evt => {
-    consumed[evt] = true;
-  };
-  structures.forEach(param => {
-    let s = param[1];
-    s.readModels.forEach(q => {
-      q.consumedEventTypes.forEach(mark);
-    });
-    s.stateViewSlices.forEach(q => {
-      q.consumedEventTypes.forEach(mark);
-    });
-    s.aggregates.forEach(w => {
-      w.consumedEventTypes.forEach(mark);
-    });
-    s.stateChangeSlices.forEach(w => {
-      w.consumedEventTypes.forEach(mark);
-    });
-    s.automationSlices.forEach(a => {
-      a.consumedEventTypes.forEach(mark);
-    });
-    s.outboundTranslationSlices.forEach(o => {
-      o.consumedEventTypes.forEach(mark);
-    });
-    s.extensions.forEach(e => {
-      e.eventTypes.forEach(mark);
-    });
-  });
-  let findings = [];
-  let scanProducers = (pluginName, writables) => {
-    writables.forEach(w => {
-      if (w.linkedViews.length !== 0) {
-        return;
-      } else {
-        w.producedEventTypes.forEach(evt => {
-          let match = consumed[evt];
-          if (match !== undefined) {
-            return;
-          } else {
-            findings.push({
-              kind: "OrphanEvent",
-              pluginName: pluginName,
-              componentName: w.name,
-              detail: evt
-            });
-            return;
-          }
-        });
-        return;
-      }
-    });
-  };
-  structures.forEach(param => {
-    let s = param[1];
-    let pluginName = param[0];
-    scanProducers(pluginName, s.aggregates);
-    scanProducers(pluginName, s.stateChangeSlices);
-  });
-  return findings;
-}
-
-let P;
-
-export {
-  P,
-  analyze,
-}
-/* No side effect */

package/src/Filter.res

@@ -1,45 +0,0 @@
-// Source-level test filters: `only`, `skip`, `xtest`, `xdescribe`.
-//
-// Jest ships `describe.only` / `test.only` / `xtest` as properties/aliases
-// on the globals; reventless-gwt exposes them as explicit helpers. When the
-// CLI runner is active, they mutate `Collector` state; when Jest is driving,
-// they forward to the Jest globals.
-
-@val external jestXTest: (string, unit => unit) => unit = "xtest"
-@val external jestXDescribe: (string, unit => unit) => unit = "xdescribe"
-
-// Mark the next registered `test` / `testPromise` as skipped.
-let skip = () => Collector.markSkipNext()
-
-// Mark the next registered `test` / `testPromise` as the focus of the run.
-// If at least one entry is flagged `Only`, only those entries execute.
-let only = () => Collector.markOnlyNext()
-
-// xtest: register a test but mark it as skipped.
-let xtest = (~slice as _: option<string>=?, name: string, _body: unit => Outcome.outcome) =>
-  if Collector.isActive() {
-    Collector.markSkipNext()
-    Collector.push(name, () => Promise.resolve(Outcome.pass))
-  } else {
-    jestXTest(name, () => ())
-  }
-
-// xdescribe: register a describe block with every nested test pre-marked
-// skipped.
-let xdescribe = (label: string, body: unit => unit) =>
-  if Collector.isActive() {
-    Collector.skipDepth := Collector.skipDepth.contents + 1
-    // Decrement on both the normal and the throwing path (ReScript has no
-    // `finally`): a body that raises must not leak the incremented depth and
-    // skip every following sibling/file.
-    try {
-      Collector.pushDescribe(label, body)
-      Collector.skipDepth := Collector.skipDepth.contents - 1
-    } catch {
-    | e =>
-      Collector.skipDepth := Collector.skipDepth.contents - 1
-      throw(e)
-    }
-  } else {
-    jestXDescribe(label, body)
-  }

package/src/Filter.res.mjs

@@ -1,47 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
-import * as Collector$ReventlessGwt from "./Collector.res.mjs";
-
-function skip() {
-  Collector$ReventlessGwt.markSkipNext();
-}
-
-function only() {
-  Collector$ReventlessGwt.markOnlyNext();
-}
-
-function xtest(param, name, _body) {
-  if (Collector$ReventlessGwt.isActive()) {
-    Collector$ReventlessGwt.markSkipNext();
-    return Collector$ReventlessGwt.push(undefined, undefined, undefined, name, () => Promise.resolve(Outcome$ReventlessGwt.pass));
-  } else {
-    globalThis.xtest(name, () => {});
-    return;
-  }
-}
-
-function xdescribe(label, body) {
-  if (Collector$ReventlessGwt.isActive()) {
-    Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents + 1 | 0;
-    try {
-      Collector$ReventlessGwt.pushDescribe(label, body);
-      Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
-      return;
-    } catch (e) {
-      Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
-      throw e;
-    }
-  } else {
-    globalThis.xdescribe(label, body);
-    return;
-  }
-}
-
-export {
-  skip,
-  only,
-  xtest,
-  xdescribe,
-}
-/* No side effect */

package/src/FormatterHuman.res

@@ -1,109 +0,0 @@
-// Terminal-coloured human formatter. Shipped as the default output for
-// `reventless-gwt run`. Uses picocolors for ANSI colours — it is a tiny
-// zero-dependency helper that transparently disables colour when stdout
-// is not a TTY.
-
-type colour = string => string
-type picocolors = {
-  red: colour,
-  green: colour,
-  yellow: colour,
-  cyan: colour,
-  gray: colour,
-  bold: colour,
-  dim: colour,
-}
-
-@module("picocolors") external pc: picocolors = "default"
-
-@val external processStdout: {"write": string => unit} = "process.stdout"
-@val external processCwd: unit => string = "process.cwd"
-@module("node:path") external pathBasename: string => string = "basename"
-@module("node:path") external pathRelative: (string, string) => string = "relative"
-
-let write = (s: string) => processStdout["write"](s)
-let writeLine = (s: string) => write(s ++ "\n")
-
-let formatFilePath = (abs: string) => {
-  let base = pathBasename(abs)
-  let name = if String.endsWith(base, ".res.mjs") {
-    String.slice(base, ~start=0, ~end=String.length(base) - 8)
-  } else {
-    base
-  }
-  let rel = pathRelative(processCwd(), abs)
-  `${name} - ${rel}`
-}
-
-let formatLocation = (loc: option<Collector.location>) =>
-  switch loc {
-  | None => ""
-  | Some(l) => `${l.file}:${Int.toString(l.line)}`
-  }
-
-// Frames one normalized field as a terminal line. Labels are padded so values
-// align at column 12 (`key:`, `expected:`, `actual:`); `error:` is its own
-// shorter form and the `Throw` stack is dumped raw beneath it.
-let renderField = (f: MismatchRender.field) =>
-  switch f {
-  | Expected(v) => `  expected: ${v}`
-  | Actual(v) => `  actual:   ${v}`
-  | Key(k) => `  key:      "${k}"`
-  | ExpectedNoEvents => "  expected no events"
-  | Error(e) => `  error: ${e}`
-  | Stack(s) => s
-  }
-
-let renderMismatch = (m: Outcome.mismatch) =>
-  MismatchRender.normalize(m).fields->Array.map(renderField)->Array.join("\n")
-
-let emitTest = (t: RunnerTypes.testResult) => {
-  let path = t.describePath->Array.join(" > ")
-  let full = path == "" ? t.name : `${path} > ${t.name}`
-  let loc = formatLocation(t.location)
-  let locStr = loc == "" ? "" : ` ${pc.dim(loc)}`
-  switch t.status {
-  | Pass => writeLine(`  ${pc.green("✓")} ${full}${locStr}`)
-  | Skip =>
-    writeLine(
-      `  ${pc.yellow("○")} ${full}${locStr} ${pc.dim(
-          t.skipReason->Option.getOr("skipped"),
-        )}`,
-    )
-  | Fail => {
-      writeLine(`  ${pc.red("✗")} ${pc.bold(full)}${locStr}`)
-      switch t.mismatch {
-      | Some(m) => {
-          writeLine("")
-          writeLine(renderMismatch(m))
-          let hint = Hint.forMismatch(~slice=?t.slice, m)
-          writeLine("")
-          writeLine(`  ${pc.cyan(Hint.format(hint))}`)
-          writeLine("")
-        }
-      | None => ()
-      }
-    }
-  }
-}
-
-let emitFile = (f: RunnerTypes.fileResult) => {
-  writeLine("")
-  writeLine(pc.bold(formatFilePath(f.path)))
-  f.tests->Array.forEach(emitTest)
-}
-
-let emitSummary = (s: RunnerTypes.summary) => {
-  writeLine("")
-  let line = `Tests: ${Int.toString(s.total)}  ${pc.green(
-      Int.toString(s.passed) ++ " passed",
-    )}  ${pc.red(Int.toString(s.failed) ++ " failed")}  ${pc.yellow(
-      Int.toString(s.skipped) ++ " skipped",
-    )}  (${Float.toString(s.durationMs)} ms)`
-  writeLine(line)
-}
-
-let emit = (r: RunnerTypes.runResult) => {
-  r.files->Array.forEach(emitFile)
-  emitSummary(r.summary)
-}