@uniflowed/vite 0.0.0-alpha.1

package/internal/config.js

@@ -0,0 +1,141 @@
+// Plain JavaScript: executed by the host that runs Vite, before any transform.
+//
+// Loading `uf.config.js`.
+//
+// The config is a Flow module — `import { defineConfig } from
+// "@uniflowed/config"` and the `// @flow` docblock are the documented shape —
+// so no host can import it as written. It is transformed through
+// `uf transform` like every other module, written under `.uf/config/`, and
+// imported from there. Relative imports inside the config are rewritten to
+// absolute URLs first, because the compiled copy does not live where the
+// author's file does.
+//
+// The result is the config *object*, functions and plugin instances included.
+// `projectConfig` is its JSON projection for the Rust side, which needs the
+// data and cannot use the functions.
+
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { transformFlow } from "../transform.js";
+
+/** The one config file name uf reads. */
+export const CONFIG_FILES = ["uf.config.js"];
+
+/** Where compiled config modules are written, relative to the project root. */
+const COMPILED_DIR = path.join(".uf", "config");
+
+/** Longest config file the loader accepts. */
+const MAX_CONFIG_BYTES = 1024 * 1024;
+
+/**
+ * Find `uf.config.js` at `root`, or `null`.
+ */
+export function findConfigFile(root) {
+  for (const name of CONFIG_FILES) {
+    const candidate = path.join(root, name);
+    try {
+      readFileSync(candidate);
+      return candidate;
+    } catch {
+      // keep looking
+    }
+  }
+  return null;
+}
+
+/**
+ * Load the project's config object.
+ *
+ * A project without a config file gets `{}`, which every consumer treats as
+ * "the defaults". A config whose default export is not an object is an error
+ * at load time, named after the file, rather than a cascade of `undefined`
+ * later.
+ *
+ * @param {string} root absolute project root
+ * @returns {Promise<{config: object, file: string | null}>}
+ */
+export async function loadUfConfig(root) {
+  const file = findConfigFile(root);
+  if (file == null) return { config: {}, file: null };
+
+  const source = readFileSync(file, "utf8");
+  if (source.length > MAX_CONFIG_BYTES) {
+    throw new Error(`uf: ${file} is ${source.length} bytes, over the ${MAX_CONFIG_BYTES} byte ceiling`);
+  }
+
+  const compiled = await compileConfig(source, file, root);
+  const module = await import(pathToFileURL(compiled).href);
+  const config = module.default;
+  if (config == null || typeof config !== "object") {
+    throw new Error(`uf: ${path.relative(root, file)} must \`export default defineConfig({ ... })\``);
+  }
+  return { config, file };
+}
+
+/**
+ * Transform the config to JavaScript and write it where it can be imported.
+ *
+ * The file name carries a hash of the source, so an edited config is a new
+ * module and never a stale cached one — `import()` caches by URL.
+ */
+async function compileConfig(source, file, root) {
+  const hash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  const directory = path.join(root, COMPILED_DIR);
+  const target = path.join(directory, `uf.config.${hash}.mjs`);
+
+  const out = await transformFlow(source, file, { root, sourceMap: false });
+  const code = rewriteRelativeImports(out?.code ?? source, path.dirname(file));
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(target, `// Compiled from ${file}. Do not edit; edit the source.\n${code}`);
+  return target;
+}
+
+/**
+ * Make every relative import specifier in `code` absolute.
+ *
+ * The compiled config lives under `.uf/config/`, so `./plugins/x.js` would
+ * otherwise resolve to a file that is not there. Bare specifiers are left
+ * alone: they resolve through `node_modules` from the compiled file exactly as
+ * they would from the source.
+ *
+ * Specifiers are string literals in `import`/`export … from` statements and
+ * `import()` calls; matching them textually is enough because the transform
+ * has already produced plain JavaScript with one statement per line.
+ */
+export function rewriteRelativeImports(code, baseDirectory) {
+  const absolute = (specifier) => pathToFileURL(path.resolve(baseDirectory, specifier)).href;
+  return code.replace(
+    /((?:\bfrom\s*|\bimport\s*\(?\s*)["'])(\.\.?\/[^"']*)(["'])/g,
+    (_, head, specifier, tail) => `${head}${absolute(specifier)}${tail}`,
+  );
+}
+
+/**
+ * The JSON projection of a config object.
+ *
+ * Functions are dropped, and a Vite plugin object is reduced to its name so
+ * `uf inspect` can still say which plugins a project declares. Everything the
+ * Rust side reads — lint rules, formatter settings, tasks, hosts — is plain
+ * data and survives unchanged.
+ */
+export function projectConfig(config) {
+  return JSON.parse(
+    JSON.stringify(config, (key, value) => {
+      if (typeof value === "function") return undefined;
+      if (key === "plugins" && Array.isArray(value)) {
+        return value.flat(Infinity).map(pluginName).filter((name) => name != null);
+      }
+      return value;
+    }),
+  );
+}
+
+function pluginName(plugin) {
+  if (plugin == null || plugin === false) return null;
+  if (typeof plugin === "string") return plugin;
+  if (typeof plugin === "object" && typeof plugin.name === "string") return plugin.name;
+  return null;
+}

package/internal/events.js

@@ -0,0 +1,68 @@
+// Plain JavaScript: executed by the host that runs Vite, before any transform.
+//
+// The driver's control channel.
+//
+// `uf dev` and `uf build` in Rust own the terminal: banners, phase timings,
+// code frames, the summary. The driver therefore never prints for a person. It
+// writes one JSON object per line to stdout — `{"event": "...", ...}` — and the
+// Rust side renders them. Anything a person would read on stderr is Vite's own
+// logger, which is redirected here as well so nothing bypasses the channel.
+
+import { createLogger } from "vite";
+
+/**
+ * Emit one event.
+ *
+ * Writes are synchronous so an event precedes a crash that follows it, and so
+ * `done` is on the pipe before the process exits.
+ */
+export function emit(event, fields = {}) {
+  process.stdout.write(`${JSON.stringify({ event, ...fields })}\n`);
+}
+
+/**
+ * A Vite logger whose every message becomes a `log` event.
+ *
+ * `clearScreen` is a no-op: the Rust side decides what the terminal shows.
+ */
+export function eventLogger(level = "info") {
+  const base = createLogger(level, { allowClearScreen: false });
+  const forward = (kind) => (message, options) => {
+    if (options?.timestamp === false && message.trim() === "") return;
+    emit("log", { level: kind, message: stripAnsi(String(message)) });
+  };
+  return {
+    ...base,
+    info: forward("info"),
+    warn: forward("warn"),
+    warnOnce: forward("warn"),
+    error: forward("error"),
+    clearScreen() {},
+    hasErrorLogged: base.hasErrorLogged,
+    hasWarned: base.hasWarned,
+  };
+}
+
+const ANSI = /\[[0-9;]*m/g;
+
+export function stripAnsi(text) {
+  return text.replace(ANSI, "");
+}
+
+/**
+ * Describe an error for the channel: message, and a location when Babel or
+ * Rolldown attached one.
+ */
+export function errorEvent(error) {
+  const fields = { message: stripAnsi(error?.message ?? String(error)) };
+  if (error?.loc && typeof error.loc === "object") {
+    fields.file = error.loc.file ?? error.id ?? null;
+    fields.line = error.loc.line ?? null;
+    fields.column = error.loc.column ?? null;
+  } else if (error?.id) {
+    fields.file = error.id;
+  }
+  if (typeof error?.frame === "string") fields.frame = stripAnsi(error.frame);
+  if (typeof error?.stack === "string") fields.stack = stripAnsi(error.stack);
+  return fields;
+}

package/internal/node-hooks.js

@@ -0,0 +1,111 @@
+// Plain JavaScript: this *is* the loader, so it cannot be Flow.
+//
+// Node.js module customization hooks that transform Flow on import.
+//
+// Registered by `@uniflowed/vite/register` (through `node:module`'s
+// `register()`), which makes `node --import @uniflowed/vite/register app.js`
+// run a Flow project directly: every `.js` module uf is responsible for is
+// transformed as it is loaded through `uf transform`, and everything else is
+// left to Node.
+//
+// Transforms are cached on disk under `.uf/cache/transform/` keyed by a hash
+// of the source, so a second run of the same file is a read rather than a
+// round trip. The cache is content-addressed: an edited file hashes
+// differently, so there is no invalidation to get wrong.
+
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { isFlowModule, transformFlow } from "../transform.js";
+
+/**
+ * Write `contents` to `target` so a concurrent reader never sees half of it.
+ *
+ * `uf test` runs one of these processes per core and they all import the same
+ * few modules at once, so two writers and a reader meet on the same cache
+ * entry constantly. `writeFileSync` is not atomic — a reader can observe a
+ * truncated file and report a module that "does not provide an export" — so
+ * the content goes to a private temporary name first and is then renamed,
+ * which is atomic within a filesystem.
+ *
+ * A failure here is not a failure: a read-only checkout still runs, just
+ * without the cache.
+ */
+function writeAtomically(target, contents) {
+  const temporary = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}`;
+  try {
+    mkdirSync(cacheDirectory, { recursive: true });
+    writeFileSync(temporary, contents);
+    renameSync(temporary, target);
+  } catch {
+    try {
+      unlinkSync(temporary);
+    } catch {
+      // Nothing to clean up.
+    }
+  }
+}
+
+/** Bumped whenever the transform's output shape changes, to retire old entries. */
+const CACHE_VERSION = "2";
+
+let cacheDirectory = null;
+let root = null;
+
+/**
+ * Called once by `register()` with `{ root }`; the cache lives under it and
+ * the transform service is started there so it reads the right config.
+ */
+export async function initialize(data) {
+  root = data?.root ?? process.cwd();
+  cacheDirectory = path.join(root, ".uf", "cache", "transform");
+}
+
+/**
+ * The `load` hook: transform Flow modules, defer everything else.
+ */
+export async function load(url, context, nextLoad) {
+  if (!url.startsWith("file:")) return nextLoad(url, context);
+  const filename = fileURLToPath(url);
+  if (!isFlowModule(filename)) return nextLoad(url, context);
+
+  const source = readFileSync(filename, "utf8");
+  const code = await cachedTransform(source, filename);
+  if (code == null) return nextLoad(url, context);
+  // uf projects are ES modules. Forcing the format here means a project whose
+  // package.json forgot `"type": "module"` still runs, rather than failing on
+  // an `import` in what Node would have guessed was CommonJS.
+  return { format: "module", source: code, shortCircuit: true };
+}
+
+async function cachedTransform(source, filename) {
+  const key = createHash("sha256")
+    .update(CACHE_VERSION)
+    .update("\0")
+    .update(filename)
+    .update("\0")
+    .update(source)
+    .digest("hex");
+  const entry = cacheDirectory ? path.join(cacheDirectory, `${key}.mjs`) : null;
+
+  if (entry) {
+    try {
+      return readFileSync(entry, "utf8");
+    } catch {
+      // not cached yet
+    }
+  }
+
+  const out = await transformFlow(source, filename, { root, development: true, sourceMap: true });
+  if (out == null) return null;
+  const output = out.map
+    ? `${out.code}\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(out.map).toString("base64")}\n`
+    : out.code;
+
+  if (entry) {
+    writeAtomically(entry, output);
+  }
+  return output;
+}