@uniflowed/vite 0.0.0-alpha.9 → 0.2.0

package/internal/server-components.js

@@ -0,0 +1,109 @@
+// @noflow
+//
+// Plain JavaScript: executed by the host that runs Vite, before any transform.
+//
+// What a project needs before its routes can render as React Server Components.
+//
+// `@uniflowed/router` installs beside React 19.2.3, the React that Expo SDK 57
+// and React Native 0.87 ship, and lists `react-server-dom-parcel` as an optional
+// peer (ubugeeei-prod/uf#992). An application rendered from its modules
+// (`app.rsc: false`) needs nothing more. One whose routes render as Server
+// Components, which is the default, needs that package and the React it was
+// released with. Without the package a build fails on an unresolved import
+// somewhere inside the router, and on too old a React it fails later, inside a
+// render, in terms of React's internals. So `uf:flow` asks here once, while Vite
+// reads its configuration, and stops with one sentence that says what the
+// project has and what to change.
+//
+// The router's own Server Components entries refuse the same React at run time
+// (`packages/router/internal/react-version.js`). This is the earlier half of the
+// same rule, for a project that builds with uf.
+
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The oldest React, and `react-server-dom-parcel`, that Server Components render on. */
+export const SERVER_COMPONENTS_REACT = "19.3.0";
+
+/**
+ * What stops the project at `root` from rendering React Server Components, as a
+ * sentence, or `null` when nothing does.
+ *
+ * Both packages are resolved the way the router's own imports resolve them: from
+ * the `@uniflowed/router` the project resolves, or from the one this package
+ * depends on when the project names none. A prerelease tag is ignored, so a 19.3
+ * canary counts as 19.3.
+ *
+ * @param {string} root
+ * @returns {string | null}
+ */
+export function serverComponentsProblem(root) {
+  const router =
+    resolveFrom(path.join(root, "package.json"), "@uniflowed/router/package.json") ??
+    resolveFrom(fileURLToPath(import.meta.url), "@uniflowed/router/package.json") ??
+    path.join(root, "package.json");
+  const react = versionOf(resolveFrom(router, "react/package.json"));
+  const flight = versionOf(resolveFrom(router, "react-server-dom-parcel/package.json"));
+
+  const found = [];
+  if (react == null) {
+    found.push("no react");
+  } else if (!isRecentEnough(react)) {
+    found.push(`React ${react}`);
+  }
+  if (flight == null) {
+    found.push("no react-server-dom-parcel");
+  } else if (!isRecentEnough(flight)) {
+    found.push(`react-server-dom-parcel ${flight}`);
+  }
+  if (found.length === 0) {
+    return null;
+  }
+  return (
+    "uf: routes render as React Server Components unless `app.rsc` is false, and that needs " +
+    `react-server-dom-parcel and React ${SERVER_COMPONENTS_REACT} or newer. This project has ` +
+    `${found.join(" and ")}. Install react, react-dom and react-server-dom-parcel at ^19.3.0, ` +
+    "or set `app.rsc: false` in uf.config.js to render routes from their modules, which the " +
+    "router supports from React 19.2.3."
+  );
+}
+
+/** Where `specifier` resolves from the file at `from`, or `null`. */
+function resolveFrom(from, specifier) {
+  try {
+    return createRequire(from).resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+
+/** The `version` in the manifest at `file`, or `null`. */
+function versionOf(file) {
+  if (file == null) {
+    return null;
+  }
+  try {
+    const { version } = JSON.parse(fs.readFileSync(file, "utf8"));
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Whether `version` is at least `SERVER_COMPONENTS_REACT`, ignoring a prerelease tag. */
+function isRecentEnough(version) {
+  const found = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  if (found == null) {
+    return false;
+  }
+  const needed = SERVER_COMPONENTS_REACT.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const part = Number(found[index + 1]);
+    if (part !== needed[index]) {
+      return part > needed[index];
+    }
+  }
+  return true;
+}

package/internal/worker-builtins.js

@@ -0,0 +1,170 @@
+// @noflow
+//
+// Plain JavaScript: `../driver.js` imports this before any transform exists.
+//
+// The Node built-ins a Cloudflare Worker does not provide at the compatibility
+// date `uf build --adapter edge` writes, and what the build says about a module
+// that reaches one.
+//
+// # Where the list comes from
+//
+// A measurement rather than a summary of the documentation. Each module below
+// was imported statically into a Worker — so Wrangler applied the polyfills it
+// applies to uf's own bundle — served by `wrangler dev --local` at compatibility
+// date 2024-09-23 with `nodejs_compat`, and the function beside it was called.
+// Every one threw `[unenv] <function> is not implemented yet!`.
+// `tools/ci/edge-worker-smoke.sh` builds that probe from this table on every run
+// and fails when a module here stops throwing or stops importing, so the list
+// cannot go on claiming something workerd no longer does.
+//
+// Whole modules only. `net` answers `connect` and refuses `createServer`, and
+// `dgram`, `inspector` and `worker_threads` construct objects without throwing;
+// a module that partly works is not one a build can name as absent. A call that
+// fails in one of those fails at request time, where `@uniflowed/server/edge`
+// names the function in the log line.
+//
+// # Reported, not refused
+//
+// The build goes on. The date is the one uf writes into `wrangler.json`, and a
+// project that deploys with a `wrangler.json` of its own at a newer date may
+// have the module — `node:fs` gained a virtual filesystem at a later one. A
+// refusal here would stop a deployment uf cannot see from being built at all,
+// so what uf owes is the sentence: which module, which file reached it, and what
+// a request that reaches it answers on uf's date.
+
+/** The compatibility date the table was measured at; `wrangler.json` pins it. */
+export const WORKERS_COMPATIBILITY_DATE = "2024-09-23";
+
+/**
+ * Every module a Worker provides only as a stub at that date, with the call
+ * that shows it.
+ *
+ * `construct` is for the one entry whose representative member is a class.
+ * The smoke builds `new wasi.WASI(...)` from it rather than a call.
+ */
+export const UNAVAILABLE_ON_WORKERS = Object.freeze([
+  Object.freeze({ module: "child_process", member: "execFileSync", args: ["true"] }),
+  Object.freeze({ module: "cluster", member: "fork", args: [] }),
+  Object.freeze({ module: "fs", member: "readFileSync", args: ["/tmp/uf-probe"] }),
+  Object.freeze({ module: "http", member: "createServer", args: [] }),
+  Object.freeze({ module: "http2", member: "createServer", args: [] }),
+  Object.freeze({ module: "https", member: "createServer", args: [] }),
+  Object.freeze({ module: "repl", member: "start", args: [] }),
+  Object.freeze({
+    module: "wasi",
+    member: "WASI",
+    construct: true,
+    args: [{ version: "preview1" }],
+  }),
+]);
+
+/** How many reached modules one build names before it counts the rest. */
+export const MAX_NAMED = 8;
+
+/**
+ * The table entry `specifier` reaches, or `null` when it reaches none.
+ *
+ * `node:fs`, `fs` and `node:fs/promises` are all `fs`: the prefix is optional
+ * in an import and a subpath is the same module's functions under another name.
+ */
+export function unavailableOnWorkers(specifier) {
+  if (typeof specifier !== "string") return null;
+  const bare = specifier.startsWith("node:") ? specifier.slice("node:".length) : specifier;
+  const name = bare.split("/")[0];
+  return UNAVAILABLE_ON_WORKERS.find((entry) => entry.module === name) ?? null;
+}
+
+/**
+ * The reached imports that are still in the output once the bundler has shaken
+ * the graph.
+ *
+ * Resolution sees every import of every module the graph names, including
+ * modules that contribute nothing to the bundle. Measured on the
+ * `rsc-split-app` fixture: a client component's top-level
+ * `import { expect, it } from "@uniflowed/test"`, kept for an in-source test
+ * that compiles to `void 0` in a build, reached `node:fs` and
+ * `node:child_process` through `@uniflowed/test` and `@uniflowed/host` — and not
+ * one byte of either was in the Worker. A warning about a module the Worker does
+ * not contain is a warning every edge project would learn to ignore.
+ *
+ * So an import counts only when a chunk of the output still imports that
+ * module *and* the importing module rendered code into that chunk. `chunks` is
+ * the bundle's chunk entries, as `generateBundle` receives them: `imports` is
+ * the chunk's external imports, `modules` its modules with `renderedLength`.
+ */
+export function survivingImports(reached, chunks) {
+  return reached.filter(({ specifier, importer }) => {
+    const entry = unavailableOnWorkers(specifier);
+    if (entry == null) return false;
+    return chunks.some(
+      (chunk) =>
+        (chunk.imports ?? []).some((name) => unavailableOnWorkers(name)?.module === entry.module) &&
+        (chunk.modules?.[importer]?.renderedLength ?? 0) > 0,
+    );
+  });
+}
+
+/**
+ * The warnings one edge build prints, one line per module and importer.
+ *
+ * `reached` is `{ specifier, importer }` in the order the bundler met them,
+ * `root` the project; an importer inside the project and outside
+ * `node_modules` is the project's own code and is named before any
+ * dependency, because it is the one a reader can change. Bounded by
+ * [`MAX_NAMED`], with the rest counted, so a dependency that reaches a stub
+ * from a hundred files cannot print a hundred lines.
+ */
+export function workerBuiltinWarnings(reached, root) {
+  const seen = new Set();
+  const lines = [];
+  for (const { specifier, importer } of reached) {
+    const entry = unavailableOnWorkers(specifier);
+    if (entry == null || importer == null) continue;
+    const key = `${entry.module}\0${importer}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const inside = isProjectModule(importer, root);
+    const from = inside ? relative(importer, root) : dependencyName(importer);
+    lines.push({
+      inside,
+      text:
+        `${from} imports node:${entry.module}, which a Cloudflare Worker at compatibility date ` +
+        `${WORKERS_COMPATIBILITY_DATE} provides only as a stub: every function of it throws. ` +
+        (inside
+          ? "A request that reaches it will answer 500 on this target."
+          : "The dependency may never call it here; if a request does, it answers 500."),
+    });
+  }
+  lines.sort((a, b) => Number(b.inside) - Number(a.inside));
+  const named = lines.slice(0, MAX_NAMED).map((line) => `--adapter edge: ${line.text}`);
+  if (lines.length > MAX_NAMED) {
+    named.push(
+      `--adapter edge: and ${lines.length - MAX_NAMED} more importers of the same modules`,
+    );
+  }
+  return named;
+}
+
+function isProjectModule(importer, root) {
+  const normalised = importer.split("\\").join("/");
+  const base = root.split("\\").join("/").replace(/\/$/, "");
+  return normalised.startsWith(`${base}/`) && !normalised.includes("/node_modules/");
+}
+
+function relative(importer, root) {
+  const base = root.split("\\").join("/").replace(/\/$/, "");
+  return importer
+    .split("\\")
+    .join("/")
+    .slice(base.length + 1);
+}
+
+/** `a dependency (name)`, from the last `node_modules/` segment of a path. */
+function dependencyName(importer) {
+  const normalised = importer.split("\\").join("/");
+  const at = normalised.lastIndexOf("/node_modules/");
+  if (at === -1) return `a module outside the project (${normalised})`;
+  const rest = normalised.slice(at + "/node_modules/".length).split("/");
+  const name = rest[0]?.startsWith("@") ? `${rest[0]}/${rest[1]}` : rest[0];
+  return `the dependency ${name}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/vite",
-  "version": "0.0.0-alpha.9",
+  "version": "0.2.0",
   "description": "Vite, driven by uf.config.js: every Flow module through `uf transform`, MDX, the file-system router and static rendering as Vite plugins.",
   "type": "module",
   "license": "MIT",
@@ -10,6 +10,14 @@
     "url": "git+https://github.com/ubugeeei-prod/uf.git",
     "directory": "packages/vite"
   },
+  "uf": {
+    "builder": {
+      "driver": "./driver.js",
+      "preload": {
+        "bun": "@uniflowed/host/bun-preload"
+      }
+    }
+  },
   "exports": {
     ".": "./index.js",
     "./driver": "./driver.js",
@@ -20,22 +28,36 @@
     "driver.js",
     "index.js",
     "internal",
-    "merge.js"
+    "merge.js",
+    "!*.test.js"
   ],
   "dependencies": {
+    "@babel/core": "^7.29.7",
     "@mdx-js/rollup": "^3.1.1",
     "@shikijs/rehype": "^3.23.0",
-    "@uniflowed/host": "0.0.0-alpha.9",
-    "@uniflowed/server": "0.0.0-alpha.9",
+    "@uniflowed/host": "0.2.0",
+    "@uniflowed/router": "0.2.0",
+    "@uniflowed/server": "0.2.0",
+    "@uniflowed/validator": "0.2.0",
+    "babel-plugin-relay": "^21.0.1",
+    "estree-util-value-to-estree": "^3.5.0",
     "rehype-slug": "^6.0.0",
     "remark-frontmatter": "^5.0.0",
     "remark-gfm": "^4.0.1",
-    "remark-mdx-frontmatter": "^5.2.0",
     "shiki": "^3.23.0",
-    "vite": "^8.2.2"
+    "unist-util-mdx-define": "^1.1.2",
+    "vite": "^8.2.2",
+    "yaml": "^2.9.1",
+    "rolldown": "^1.2.7"
   },
   "peerDependencies": {
+    "axe-core": ">=4",
     "react": ">=19",
     "react-dom": ">=19"
+  },
+  "peerDependenciesMeta": {
+    "axe-core": {
+      "optional": true
+    }
   }
 }