@rivetjs/nx 0.0.0-stage → 0.1.0-alpha.0

package/generators/application/schema.d.ts

@@ -0,0 +1,24 @@
+export interface ApplicationGeneratorSchema {
+  /** Project folder, workspace-relative (`apps/web`). */
+  directory: string;
+  /** Project name (default: the folder name). */
+  name?: string;
+  /** Starter: `static` (prerendered pages, Tailwind), `server` (loader + action, Node), `ui` (@rivetjs/ui), `minimal`. */
+  template?: "static" | "server" | "ui" | "minimal";
+  /** `node`: pages render per request (`@rivetjs/router/node`); `static`: prerendered HTML files. Default: from the template. */
+  adapter?: "node" | "static";
+  /** Platform target (create-rivet `--deploy`): adapter + platform files; `deploy` / `preview` Nx targets. bun / deno: server template. */
+  deploy?: "vercel" | "netlify" | "cloudflare" | "bun" | "deno";
+  /** Tailwind v4. Default: on, except the minimal starter. */
+  tailwind?: boolean;
+  /** `vitest`: vitest.config.ts with rivetTest() + a first test. */
+  unitTestRunner?: "vitest" | "none";
+  /** Comma-separated project tags. */
+  tags?: string;
+  /** `@rivetjs/*` dependency spec (default: this plugin's version). */
+  rivetVersion?: string;
+  addPlugin?: boolean;
+  skipPackageJson?: boolean;
+  skipInstall?: boolean;
+  skipFormat?: boolean;
+}

package/generators/application/schema.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RivetApplication",
+  "title": "Rivet application",
+  "description": "Creates a Rivet app from one of the create-rivet starters, with Nx targets (inferred or in project.json) and an optional Vitest setup.",
+  "type": "object",
+  "properties": {
+    "directory": {
+      "type": "string",
+      "description": "Project folder, relative to the workspace root (e.g. apps/web).",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Which directory do you want to create the application in?"
+    },
+    "name": { "type": "string", "description": "Project name (default: the folder name).", "pattern": "^[a-zA-Z][^:]*$" },
+    "template": {
+      "type": "string",
+      "enum": ["static", "server", "ui", "minimal"],
+      "default": "static",
+      "description": "Starter: static (prerendered pages, Tailwind), server (loader + form action per request, Node), ui (@rivetjs/ui + Tailwind v4), minimal (one page, no Tailwind).",
+      "x-prompt": {
+        "message": "Which starter?",
+        "type": "list",
+        "items": [
+          { "value": "static", "label": "Static site (prerendered pages, Tailwind)" },
+          { "value": "server", "label": "Node server (loader + form action per request)" },
+          { "value": "ui", "label": "UI components (@rivetjs/ui + Tailwind v4)" },
+          { "value": "minimal", "label": "Minimal (one page, one signal)" }
+        ]
+      }
+    },
+    "adapter": {
+      "type": "string",
+      "enum": ["node", "static"],
+      "description": "node: pages render per request; static: prerendered HTML files. Default: from the template (server → node, others → static)."
+    },
+    "deploy": {
+      "type": "string",
+      "enum": ["vercel", "netlify", "cloudflare", "bun", "deno"],
+      "description": "Platform target, the same files as create-rivet --deploy: rivetRouter({ adapter }) + platform config; Nx targets instead of npm scripts (vercel / cloudflare: deploy; cloudflare / bun / deno: preview). bun and deno need --template=server."
+    },
+    "tailwind": { "type": "boolean", "description": "Tailwind v4. Default: on, except the minimal starter." },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["vitest", "none"],
+      "default": "vitest",
+      "description": "Test runner: vitest.config.ts with rivetTest() and a first test."
+    },
+    "tags": { "type": "string", "description": "Comma-separated project tags." },
+    "rivetVersion": { "type": "string", "description": "@rivetjs/* dependency spec (default: this plugin's version)." },
+    "addPlugin": { "type": "boolean", "x-priority": "internal", "description": "Use inferred targets (default: true unless NX_ADD_PLUGINS=false)." },
+    "skipPackageJson": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Do not add dependencies to the root package.json." },
+    "skipInstall": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Do not run the package manager install." },
+    "skipFormat": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Skip formatting files." }
+  },
+  "required": ["directory"],
+  "additionalProperties": false
+}

package/generators/component/files/basic/__fileName__.tsx.template

@@ -0,0 +1,24 @@
+import { signal } from "@rivetjs/reactivity";
+import type { Content } from "@rivetjs/runtime/jsx-runtime";
+
+export interface <%= className %>Props {
+  /** Button text. */
+  label?: string;
+  children?: Content;
+}
+
+/**
+ * <%= className %>. The click handler is an inline arrow: the compiler captures it, so on a resumed page the button
+ * works without running the component in the browser (its code loads on first interaction).
+ */
+export function <%= className %>(props: <%= className %>Props) {
+  const count = signal(0);
+  return (
+    <div class="<%= cssName %>">
+      {props.children}
+      <button type="button" onClick={() => count.update((n) => n + 1)}>
+        {props.label ?? "Clicked"} {count()}
+      </button>
+    </div>
+  );
+}

package/generators/component/files/overlay/__fileName__.tsx.template

@@ -0,0 +1,32 @@
+import { signal } from "@rivetjs/reactivity";
+import type { Slot } from "@rivetjs/runtime/jsx-runtime";
+
+export interface <%= className %>Props {
+  /** Trigger text (also the panel's accessible name). */
+  label: string;
+  /**
+   * Render-function children (`{() => <p>…</p>}`): the content of the closed panel is created when it opens, also on a
+   * resumed page. Plain JSX children would be created right away and kept for later, which a resumed page cannot save.
+   */
+  children: Slot;
+}
+
+/** <%= className %>: a trigger and a panel that opens below it. Handlers are inline arrows (resumable). */
+export function <%= className %>(props: <%= className %>Props) {
+  const open = signal(false);
+  return (
+    <div class="<%= cssName %>">
+      <button type="button" aria-expanded={open() ? "true" : "false"} onClick={() => open.update((value) => !value)}>
+        {props.label}
+      </button>
+      {open() && (
+        <div role="dialog" aria-label={props.label}>
+          {props.children()}
+          <button type="button" onClick={() => open.set(false)}>
+            Close
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}

package/generators/component/files/story/__storyName__.tsx.template

@@ -0,0 +1,24 @@
+import { <%= className %> } from "<%= importPath %>";
+
+export const head = { title: "<%= className %> story" };
+
+/** Story page of <%= className %> (<%= url %>): its states side by side. */
+export default function <%= className %>Story() {
+  return (
+    <main>
+      <h1><%= className %></h1>
+      <section>
+        <h2>Default</h2>
+<% if (overlay) { %>        <<%= className %> label="Open">{() => <p>Panel content</p>}</<%= className %>>
+<% } else { %>        <<%= className %> />
+<% } %>      </section>
+      <section>
+        <h2>With content</h2>
+<% if (overlay) { %>        <<%= className %> label="More">{() => <ul><li>One</li><li>Two</li></ul>}</<%= className %>>
+<% } else { %>        <<%= className %> label="Likes">
+          <p>Children render above the button.</p>
+        </<%= className %>>
+<% } %>      </section>
+    </main>
+  );
+}

package/generators/component/files/test-basic/__fileName__.test.tsx.template

@@ -0,0 +1,10 @@
+import { expect, test } from "vitest";
+import { fire, render } from "@rivetjs/runtime/testing";
+import { <%= className %> } from "./<%= fileName %>.tsx";
+
+test("<%= className %> counts clicks", () => {
+  const view = render(() => <<%= className %> label="Count" />);
+  const button = view.find("button");
+  fire(button, "click");
+  expect(button.textContent).toBe("Count 1");
+});

package/generators/component/files/test-overlay/__fileName__.test.tsx.template

@@ -0,0 +1,10 @@
+import { expect, test } from "vitest";
+import { fire, render } from "@rivetjs/runtime/testing";
+import { <%= className %> } from "./<%= fileName %>.tsx";
+
+test("<%= className %> creates its content when it opens", () => {
+  const view = render(() => <<%= className %> label="Details">{() => <p>Inside</p>}</<%= className %>>);
+  expect(view.container.querySelector("p")).toBeNull();
+  fire(view.find("button"), "click");
+  expect(view.find("[role=dialog] p").textContent).toBe("Inside");
+});

package/generators/component/generator.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from "@nx/devkit";
+import type { ComponentGeneratorSchema } from "./schema.js";
+export type { ComponentGeneratorSchema } from "./schema.js";
+export declare function componentGenerator(tree: Tree, options: ComponentGeneratorSchema): Promise<void>;
+export default componentGenerator;

package/generators/component/generator.js

@@ -0,0 +1,45 @@
+// `nx g @rivetjs/nx:component UserCard --project=web [--kind=overlay] [--story] [--no-test]`.
+import { fileURLToPath } from "node:url";
+import { formatFiles, generateFiles, joinPathFragments, names } from "@nx/devkit";
+import { relativeImport, rivetProject } from "../../utils/project.js";
+const FILES = fileURLToPath(new URL("./files", import.meta.url));
+export async function componentGenerator(tree, options) {
+    const project = rivetProject(tree, options.project);
+    const { className } = names(options.name);
+    if (!/^[A-Z][A-Za-z0-9]*$/.test(className))
+        throw new Error(`component: "${options.name}" is not a valid component name`);
+    const kind = options.kind ?? "basic";
+    const directory = (options.directory ?? (project.library ? "" : "components")).replace(/^\/+|\/+$/g, "");
+    const folder = joinPathFragments(project.src, directory);
+    const file = joinPathFragments(folder, `${className}.tsx`);
+    if (tree.exists(file))
+        throw new Error(`component: ${file} already exists`);
+    // The file keeps the component name (`UserCard.tsx`); the markup class is kebab-case (`user-card`).
+    const vars = { className, fileName: className, cssName: names(className).fileName, overlay: kind === "overlay" };
+    generateFiles(tree, joinPathFragments(FILES, kind), folder, vars);
+    if (options.test ?? Boolean(project.facts?.test))
+        generateFiles(tree, joinPathFragments(FILES, `test-${kind}`), folder, vars);
+    if (options.story) {
+        if (project.facts?.kind !== "app")
+            throw new Error("component: --story needs a Rivet app with file routes");
+        const stories = joinPathFragments(project.routes, "stories");
+        const storyName = names(className).fileName;
+        generateFiles(tree, joinPathFragments(FILES, "story"), stories, {
+            ...vars,
+            storyName,
+            url: `/stories/${storyName}`,
+            importPath: relativeImport(stories, file),
+        });
+    }
+    if (options.export ?? project.library) {
+        const index = joinPathFragments(project.src, "index.ts");
+        const from = relativeImport(project.src, file);
+        const line = `export { ${className}, type ${className}Props } from "${from}";\n`;
+        const text = tree.exists(index) ? tree.read(index, "utf8") : "";
+        if (!text.includes(line))
+            tree.write(index, (text && !text.endsWith("\n") ? text + "\n" : text) + line);
+    }
+    if (!options.skipFormat)
+        await formatFiles(tree);
+}
+export default componentGenerator;

package/generators/component/schema.d.ts

@@ -0,0 +1,17 @@
+export interface ComponentGeneratorSchema {
+  /** Component name (PascalCase or any case: `user-card` → `UserCard`). */
+  name: string;
+  /** The app or library. */
+  project: string;
+  /** Folder under the project's `src` (default `components` for apps, `` for libraries). */
+  directory?: string;
+  /** `basic` (signal + inline handler) or `overlay` (trigger + panel with render-function children). */
+  kind?: "basic" | "overlay";
+  /** Write `<Name>.test.tsx`. Default: when the project has a vitest config. */
+  test?: boolean;
+  /** Story page route `src/routes/stories/<name>.tsx` (apps only). */
+  story?: boolean;
+  /** Re-export from the library's `src/index.ts`. Default: true for libraries. */
+  export?: boolean;
+  skipFormat?: boolean;
+}

package/generators/component/schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RivetComponent",
+  "title": "Rivet component",
+  "description": "Adds a resumability-correct component (.tsx) to a Rivet app or library: inline-arrow handlers, render-function children for overlays, plus a test and an optional story route.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Component name (user-card becomes UserCard).",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Component name?"
+    },
+    "project": {
+      "type": "string",
+      "description": "The app or library.",
+      "$default": { "$source": "projectName" },
+      "x-dropdown": "projects",
+      "x-prompt": "Which project?"
+    },
+    "directory": { "type": "string", "description": "Folder under the project's src (default components for apps, the src root for libraries)." },
+    "kind": {
+      "type": "string",
+      "enum": ["basic", "overlay"],
+      "default": "basic",
+      "description": "basic: signal + inline handler; overlay: trigger + panel with render-function children."
+    },
+    "test": { "type": "boolean", "description": "Write <Name>.test.tsx. Default: when the project has a vitest config." },
+    "story": { "type": "boolean", "default": false, "description": "Story page route src/routes/stories/<name>.tsx (apps only)." },
+    "export": { "type": "boolean", "description": "Re-export from the library's src/index.ts. Default: true for libraries." },
+    "skipFormat": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Skip formatting files." }
+  },
+  "required": ["name", "project"],
+  "additionalProperties": false
+}

package/generators/i18n-setup/files/i18n.config.ts.template

@@ -0,0 +1,10 @@
+import type { I18nRouteConfig } from "@rivetjs/i18n/router";
+
+// Locales (the default first), ICU catalogs per locale, and how the locale appears in URLs. Used by the i18n() Vite
+// plugin (vite.config.ts) and by `i18nGuard(config)` in a `[[lang]]` layout (see the Locale URLs guide).
+export const config = {
+  locales: <%- localesJson %>,
+  defaultLocale: "<%= defaultLocale %>",
+  catalogs: "locales/{locale}.json",
+  routing: { prefix: "<%= prefix %>" },
+} satisfies I18nRouteConfig & { catalogs: string };

package/generators/i18n-setup/generator.d.ts

@@ -0,0 +1,7 @@
+import { type GeneratorCallback, type Tree } from "@nx/devkit";
+import type { I18nSetupGeneratorSchema } from "./schema.js";
+export type { I18nSetupGeneratorSchema } from "./schema.js";
+/** A first catalog: one plain message and one with a plural (ICU MessageFormat). */
+export declare function catalog(locale: string): Record<string, unknown>;
+export declare function i18nSetupGenerator(tree: Tree, options: I18nSetupGeneratorSchema): Promise<GeneratorCallback>;
+export default i18nSetupGenerator;

package/generators/i18n-setup/generator.js

@@ -0,0 +1,65 @@
+// `nx g @rivetjs/nx:i18n-setup web --locales=en,de`: compile-time i18n (`t()` calls are replaced per locale at build
+// time). The inferred build target reads `locales` from i18n.config.ts: one client build per locale (`RIVET_LOCALE`).
+import { fileURLToPath } from "node:url";
+import { addDependenciesToPackageJson, formatFiles, generateFiles, installPackagesTask, joinPathFragments, readJson, writeJson, } from "@nx/devkit";
+import { viteConfigPath } from "../../utils/facts.js";
+import { routedApp } from "../../utils/project.js";
+import { rivetRange } from "../../utils/versions.js";
+import { addImport, addPlugin } from "../../utils/vite-config.js";
+import { ensureLines, isWorkspacePackage } from "../../utils/workspace.js";
+const FILES = fileURLToPath(new URL("./files", import.meta.url));
+/** A first catalog: one plain message and one with a plural (ICU MessageFormat). */
+export function catalog(locale) {
+    const german = locale.startsWith("de");
+    return german
+        ? { home: { title: "Willkommen", items: "{count, plural, one {# Eintrag} other {# Einträge}}" } }
+        : { home: { title: "Welcome", items: "{count, plural, one {# item} other {# items}}" } };
+}
+export async function i18nSetupGenerator(tree, options) {
+    const project = routedApp(tree, options.project, "i18n-setup");
+    const configFile = joinPathFragments(project.root, "i18n.config.ts");
+    if (tree.exists(configFile))
+        throw new Error(`i18n-setup: ${configFile} already exists`);
+    const locales = (options.locales ?? "en")
+        .split(",")
+        .map((locale) => locale.trim())
+        .filter(Boolean);
+    if (!locales.length)
+        throw new Error("i18n-setup: no locales");
+    const defaultLocale = options.defaultLocale ?? locales[0];
+    if (!locales.includes(defaultLocale))
+        throw new Error(`i18n-setup: defaultLocale "${defaultLocale}" is not in locales`);
+    generateFiles(tree, FILES, project.root, { localesJson: JSON.stringify(locales), defaultLocale, prefix: options.prefix ?? "as-needed" });
+    for (const locale of locales) {
+        const path = joinPathFragments(project.root, "locales", `${locale}.json`);
+        if (!tree.exists(path))
+            writeJson(tree, path, catalog(locale));
+    }
+    const vite = viteConfigPath(tree, project.root);
+    let config = tree.read(vite, "utf8");
+    config = addImport(config, 'import { i18n } from "@rivetjs/i18n/vite";');
+    config = addImport(config, 'import { config as i18nConfig } from "./i18n.config.ts";');
+    // i18n() runs before the router / compiler (`enforce: "pre"`); first in the list keeps that obvious.
+    config = addPlugin(config, "i18n(i18nConfig)", "first");
+    tree.write(vite, config);
+    // Generated message types (`dts` default) are build output.
+    ensureLines(tree, joinPathFragments(project.root, ".gitignore"), ["src/rivet-i18n.d.ts"]);
+    let install = () => { };
+    if (!options.skipPackageJson) {
+        const deps = { "@rivetjs/i18n": rivetRange(options.rivetVersion) };
+        const pkgPath = joinPathFragments(project.root, "package.json");
+        if (tree.exists(pkgPath)) {
+            const pkg = readJson(tree, pkgPath);
+            pkg.dependencies = { ...pkg.dependencies, ...deps };
+            writeJson(tree, pkgPath, pkg);
+        }
+        const workspacePackage = tree.exists(pkgPath) && isWorkspacePackage(tree, project.root);
+        if (!workspacePackage)
+            addDependenciesToPackageJson(tree, deps, {});
+        install = () => installPackagesTask(tree, workspacePackage);
+    }
+    if (!options.skipFormat)
+        await formatFiles(tree);
+    return install;
+}
+export default i18nSetupGenerator;

package/generators/i18n-setup/schema.d.ts

@@ -0,0 +1,13 @@
+export interface I18nSetupGeneratorSchema {
+  /** The Rivet app. */
+  project: string;
+  /** Comma-separated locales, the default first (`en,de`). */
+  locales?: string;
+  /** Default locale (default: the first of `locales`). */
+  defaultLocale?: string;
+  /** Locale prefix in URLs: `as-needed` (default), `always`, `never`. */
+  prefix?: "as-needed" | "always" | "never";
+  rivetVersion?: string;
+  skipPackageJson?: boolean;
+  skipFormat?: boolean;
+}

package/generators/i18n-setup/schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RivetI18nSetup",
+  "title": "Set up @rivetjs/i18n",
+  "description": "Adds compile-time i18n to a Rivet app: i18n.config.ts, one ICU catalog per locale (locales/<locale>.json), the i18n() Vite plugin before the router, and the dependency. The build target then runs one client build per locale.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The Rivet app.",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-dropdown": "projects",
+      "x-prompt": "Which project?"
+    },
+    "locales": { "type": "string", "default": "en", "description": "Comma-separated locales, the default first (en,de)." },
+    "defaultLocale": { "type": "string", "description": "Default locale (default: the first locale)." },
+    "prefix": { "type": "string", "enum": ["as-needed", "always", "never"], "default": "as-needed", "description": "Locale prefix in URLs." },
+    "rivetVersion": { "type": "string", "description": "@rivetjs/* dependency spec (default: this plugin's version)." },
+    "skipPackageJson": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Do not change package.json files." },
+    "skipFormat": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Skip formatting files." }
+  },
+  "required": ["project"],
+  "additionalProperties": false
+}

package/generators/init/generator.d.ts

@@ -0,0 +1,8 @@
+import { type GeneratorCallback, type Tree } from "@nx/devkit";
+import type { InitGeneratorSchema } from "./schema.js";
+export type { InitGeneratorSchema } from "./schema.js";
+export declare const PLUGIN = "@rivetjs/nx/plugin";
+/** Adds `@rivetjs/nx/plugin` to nx.json `plugins` (unless it is already there, as a string or `{ plugin }`). */
+export declare function registerPlugin(tree: Tree): void;
+export declare function initGenerator(tree: Tree, options?: InitGeneratorSchema): Promise<GeneratorCallback>;
+export default initGenerator;

package/generators/init/generator.js

@@ -0,0 +1,48 @@
+// `nx g @rivetjs/nx:init`: workspace setup shared by every other generator (idempotent).
+import { addDependenciesToPackageJson, formatFiles, readNxJson, updateNxJson } from "@nx/devkit";
+import { rivetRange, toolVersion } from "../../utils/versions.js";
+import { ensureLines, shouldAddPlugin } from "../../utils/workspace.js";
+export const PLUGIN = "@rivetjs/nx/plugin";
+/** Adds `@rivetjs/nx/plugin` to nx.json `plugins` (unless it is already there, as a string or `{ plugin }`). */
+export function registerPlugin(tree) {
+    const nxJson = readNxJson(tree) ?? {};
+    const plugins = nxJson.plugins ?? [];
+    if (plugins.some((entry) => (typeof entry === "string" ? entry : entry.plugin) === PLUGIN))
+        return;
+    plugins.push({
+        plugin: PLUGIN,
+        options: {
+            buildTargetName: "build",
+            devTargetName: "dev",
+            previewTargetName: "preview",
+            testTargetName: "test",
+            checkTargetName: "check",
+            typecheckTargetName: "typecheck",
+        },
+    });
+    nxJson.plugins = plugins;
+    updateNxJson(tree, nxJson);
+}
+export async function initGenerator(tree, options = {}) {
+    if (shouldAddPlugin(tree, options.addPlugin))
+        registerPlugin(tree);
+    ensureLines(tree, ".gitignore", [".rivet", "dist"]);
+    let install = () => { };
+    if (!options.skipPackageJson) {
+        const rivet = rivetRange(options.rivetVersion);
+        install = addDependenciesToPackageJson(tree, {}, {
+            "@rivetjs/nx": rivet,
+            "@rivetjs/compiler": rivet,
+            "@rivetjs/language-core": rivet,
+            "@rivetjs/typescript-plugin": rivet,
+            vite: toolVersion("vite"),
+            typescript: toolVersion("typescript"),
+            "@types/node": toolVersion("@types/node"),
+        }, undefined, options.keepExistingVersions);
+    }
+    if (!options.skipFormat)
+        await formatFiles(tree);
+    // The callback installs the added packages (`installPackagesTask`), after the files are on disk.
+    return options.skipInstall ? () => { } : install;
+}
+export default initGenerator;

package/generators/init/schema.d.ts

@@ -0,0 +1,13 @@
+export interface InitGeneratorSchema {
+  /** Register `@rivetjs/nx/plugin` in nx.json (inferred targets). Default: true unless `NX_ADD_PLUGINS=false` / `useInferencePlugins: false`. */
+  addPlugin?: boolean;
+  /** Do not add dependencies to the root package.json. */
+  skipPackageJson?: boolean;
+  /** Keep versions already in package.json. */
+  keepExistingVersions?: boolean;
+  /** `@rivetjs/*` dependency spec (default: this plugin's version). */
+  rivetVersion?: string;
+  /** Do not run the package manager install after generating. */
+  skipInstall?: boolean;
+  skipFormat?: boolean;
+}

package/generators/init/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RivetInit",
+  "title": "Initialize @rivetjs/nx",
+  "description": "Adds @rivetjs/nx and the shared Rivet tooling to the workspace and registers the inference plugin in nx.json.",
+  "type": "object",
+  "properties": {
+    "addPlugin": {
+      "type": "boolean",
+      "description": "Register @rivetjs/nx/plugin in nx.json (inferred targets). Default: true unless NX_ADD_PLUGINS=false or nx.json useInferencePlugins is false."
+    },
+    "skipPackageJson": { "type": "boolean", "default": false, "description": "Do not add dependencies to the root package.json." },
+    "keepExistingVersions": { "type": "boolean", "default": false, "description": "Keep versions already in package.json." },
+    "rivetVersion": { "type": "string", "description": "@rivetjs/* dependency spec (default: this plugin's version)." },
+    "skipInstall": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Do not run the package manager install." },
+    "skipFormat": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Skip formatting files." }
+  },
+  "additionalProperties": false
+}

package/generators/layout/files/_layout.tsx.template

@@ -0,0 +1,12 @@
+<% if (guard) { %>import { redirect, type LayoutProps, type RequestEvent } from "@rivetjs/router";
+
+/** Runs for every page and endpoint in this folder, before their loaders. */
+export const serverGuard = ({ cookies, url }: RequestEvent) => {
+  if (!cookies.get("session")) return redirect("/login?next=" + encodeURIComponent(url.pathname));
+};
+<% } else { %>import type { LayoutProps } from "@rivetjs/router";
+<% } %>
+/** Wraps every page in <%= where %>. Stays mounted across client navigation between them. */
+export default function <%= componentName %>({ children }: LayoutProps) {
+  return <div class="<%= className %>">{children}</div>;
+}

package/generators/layout/generator.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from "@nx/devkit";
+import type { LayoutGeneratorSchema } from "./schema.js";
+export type { LayoutGeneratorSchema } from "./schema.js";
+export declare function layoutGenerator(tree: Tree, options: LayoutGeneratorSchema): Promise<void>;
+export default layoutGenerator;

package/generators/layout/generator.js

@@ -0,0 +1,23 @@
+// `nx g @rivetjs/nx:layout blog --project=web [--guard]`: `src/routes/<directory>/_layout.tsx`.
+import { fileURLToPath } from "node:url";
+import { formatFiles, generateFiles, joinPathFragments, names } from "@nx/devkit";
+import { routeComponentName, routedApp, routeSegments } from "../../utils/project.js";
+const FILES = fileURLToPath(new URL("./files", import.meta.url));
+export async function layoutGenerator(tree, options) {
+    const project = routedApp(tree, options.project, "layout");
+    const segments = routeSegments(options.directory ?? "");
+    const folder = joinPathFragments(project.routes, ...segments);
+    const file = joinPathFragments(folder, "_layout.tsx");
+    if (tree.exists(file))
+        throw new Error(`layout: ${file} already exists`);
+    const base = segments.length ? routeComponentName(segments) : "Root";
+    generateFiles(tree, FILES, folder, {
+        componentName: base + "Layout",
+        className: names(base).fileName + "-layout",
+        where: segments.length ? `src/routes/${segments.join("/")}` : "the app",
+        guard: Boolean(options.guard),
+    });
+    if (!options.skipFormat)
+        await formatFiles(tree);
+}
+export default layoutGenerator;

package/generators/layout/schema.d.ts

@@ -0,0 +1,9 @@
+export interface LayoutGeneratorSchema {
+  /** Folder under `src/routes` the layout wraps (`blog`, `(marketing)`); empty = the root layout. */
+  directory?: string;
+  /** The Rivet app. */
+  project: string;
+  /** `serverGuard` for the whole folder (redirects to /login without a `session` cookie). */
+  guard?: boolean;
+  skipFormat?: boolean;
+}

package/generators/layout/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RivetLayout",
+  "title": "Rivet layout",
+  "description": "Adds a _layout.tsx to a folder of a Rivet app's routes (the root layout without a directory), optionally with a serverGuard for everything below it.",
+  "type": "object",
+  "properties": {
+    "directory": {
+      "type": "string",
+      "default": "",
+      "description": "Folder under src/routes the layout wraps (blog, (marketing)); empty for the root layout.",
+      "$default": { "$source": "argv", "index": 0 }
+    },
+    "project": {
+      "type": "string",
+      "description": "The Rivet app.",
+      "$default": { "$source": "projectName" },
+      "x-dropdown": "projects",
+      "x-prompt": "Which project?"
+    },
+    "guard": { "type": "boolean", "default": false, "description": "Add a serverGuard for the whole folder." },
+    "skipFormat": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Skip formatting files." }
+  },
+  "required": ["project"],
+  "additionalProperties": false
+}

package/generators/library/files/lib/README.md.template

@@ -0,0 +1,18 @@
+# <%= importPath %>
+
+Rivet library. Components are `.tsx` modules compiled by the app's Rivet compiler (`rivetRouter()` / `rivet()` in the
+app's Vite config), so they resume like the app's own components.
+
+```tsx
+import { <%= className %> } from "<%= importPath %>";
+```
+<% if (subpaths.length) { %>
+Subpaths (each one tree-shakes on its own):
+<% for (const subpath of subpaths) { %>
+- `<%= importPath %>/<%= subpath.fileName %>`<% } %>
+<% } %>
+## Nx
+
+- `nx test <%= name %>`: Vitest (DOM + server targets)
+- `nx check <%= name %>` / `nx typecheck <%= name %>`<% if (publishable) { %>
+- `nx build <%= name %>`: publishable package in `<%= outputPath %>` (`.js` / `.jsx` + `.d.ts`)<% } %>