@noverax/courier-build 0.0.0-stage → 0.5.0

package/lib/webpack/loader.d.cts

@@ -0,0 +1,40 @@
+/**
+ * What of a loader's context the routes loader uses. webpack and Rspack give
+ * all of it; Turbopack runs webpack loaders with a part of it, so what it may
+ * lack is optional and used only where it is there.
+ */
+interface RoutesLoaderContext {
+  /** The module the loader runs on, absolute. */
+  readonly resourcePath: string;
+  /** `"production"` in a build, `"development"` under a dev server; Turbopack names none. */
+  readonly mode?: string | undefined;
+  /** The options the rule hands the loader. */
+  getOptions(): unknown;
+  /** Whether the loader's result may be kept for the same inputs: never for the routes. */
+  cacheable(flag?: boolean): void;
+  /** Mark the loader asynchronous; the callback ends it with an error or the module's code. */
+  async(): (error: Error | null, content?: string) => void;
+  /** Build the module again when this file changes. */
+  addDependency(file: string): void;
+  /** Build the module again when an entry of this folder is added or removed. */
+  addContextDependency?(folder: string): void;
+  /** Build the module again once this path, absent now, appears. */
+  addMissingDependency?(path: string): void;
+  /** Report an error while the module still builds: what a dev server shows over the page. */
+  emitError?(error: Error): void;
+}
+/**
+ * The loader webpack, Rspack and Turbopack run on the module
+ * `@noverax/courier/routes` ships, which they load as CommonJS: it hands the
+ * work to the package's ES modules. Its result is never kept for the same
+ * inputs, as the routes may follow a variable the config reads, which no
+ * bundler sees; the engine reads them again only when what they came from
+ * has changed.
+ *
+ * @example
+ * ```ts
+ * config.module.rules.push({ test: stubFile, use: [{ loader: routesLoaderFile(), options: { root } }] });
+ * ```
+ */
+declare function courierRoutesLoader(this: RoutesLoaderContext): void;
+export = courierRoutesLoader;

package/lib/webpack/run-routes-loader.d.ts

@@ -0,0 +1,22 @@
+import { t as RoutesLoaderContext } from "../routes-loader-context-40OKDrQp.js";
+/**
+ * What the routes loader gives for the module it runs on: the routes read
+ * from the project's config, as a page's bundle and a server's take them, in
+ * place of the module `@noverax/courier/routes` ships; or, on the config
+ * itself in a page's bundle, a refusal.
+ *
+ * Every file the routes came from is handed to the bundler, which builds the
+ * module again when one changes. When the routes cannot be read, a build
+ * fails with why; a dev server keeps the routes it read last and reports why
+ * over the page, and with none read yet, the module fails with the reason.
+ *
+ * @param context - The loader's context
+ * @returns The module's code
+ * @throws RoutesReadError when the routes cannot be read in a build, or ever were
+ * @throws Error on the config itself, in a page's bundle
+ * @example
+ * ```ts
+ * const code = await runRoutesLoader(this);
+ * ```
+ */
+export declare function runRoutesLoader(context: RoutesLoaderContext): Promise<string>;

package/lib/webpack/run-routes-loader.js

@@ -0,0 +1,103 @@
+import { t as RoutesReadError } from "../routes-read-error-DQhKIE2F.js";
+import { n as routesModuleCode } from "../routes-module-code-DYtP7uj1.js";
+import { n as isRecord } from "../errno-code-CNx_E80R.js";
+import { t as configInPageMessage } from "../config-in-page-message-DLd3f0Jd.js";
+import { t as sharedEngine } from "../shared-engine-D0j7uXg8.js";
+import { statSync } from "node:fs";
+// src/webpack/follow-loader-inputs.ts
+/**
+* Hand the bundler what a reading of the routes read, so that a change to
+* any of it builds the routes module again: each file there, each path that
+* is not there yet, should one appear, and each folder whose entries the
+* reading listed. A bundler that has no way to follow a missing path or a
+* folder's entries is told the rest.
+*
+* @param context - The loader's context
+* @param inputs - What the reading read, whether it gave routes or failed
+* @example
+* ```ts
+* followLoaderInputs(this, snapshot);
+* ```
+*/
+function followLoaderInputs(context, inputs) {
+	for (const path of inputs.files) if (isThere(path)) context.addDependency(path);
+	else context.addMissingDependency?.(path);
+	for (const folder of inputs.listed ?? []) context.addContextDependency?.(folder);
+}
+function isThere(path) {
+	try {
+		return statSync(path, { throwIfNoEntry: false }) !== void 0;
+	} catch {
+		return true;
+	}
+}
+// src/webpack/routes-loader-options.ts
+/**
+* The loader's options, as the rule handed them.
+*
+* @param value - What the loader context's `getOptions()` gave
+* @returns The options
+* @throws Error when they are not the ones a Courier rule hands it
+* @example
+* ```ts
+* routesLoaderOptionsOf(this.getOptions()); // { root: "/app" }
+* ```
+*/
+function routesLoaderOptionsOf(value) {
+	const root = isRecord(value) ? value.root : void 0;
+	if (!isRecord(value) || typeof root !== "string") throw new Error("[courier] The routes loader was given no project root: add it through Courier's plugin or routesRule(), not by hand.");
+	return {
+		root,
+		config: typeof value.config === "string" ? value.config : void 0,
+		refuse: value.refuse === "config-in-page" ? "config-in-page" : void 0
+	};
+}
+// src/webpack/run-routes-loader.ts
+/**
+* What the routes loader gives for the module it runs on: the routes read
+* from the project's config, as a page's bundle and a server's take them, in
+* place of the module `@noverax/courier/routes` ships; or, on the config
+* itself in a page's bundle, a refusal.
+*
+* Every file the routes came from is handed to the bundler, which builds the
+* module again when one changes. When the routes cannot be read, a build
+* fails with why; a dev server keeps the routes it read last and reports why
+* over the page, and with none read yet, the module fails with the reason.
+*
+* @param context - The loader's context
+* @returns The module's code
+* @throws RoutesReadError when the routes cannot be read in a build, or ever were
+* @throws Error on the config itself, in a page's bundle
+* @example
+* ```ts
+* const code = await runRoutesLoader(this);
+* ```
+*/
+async function runRoutesLoader(context) {
+	const options = routesLoaderOptionsOf(context.getOptions());
+	if (options.refuse === "config-in-page") throw new Error(configInPageMessage(context.resourcePath));
+	const engine = sharedEngine({
+		root: options.root,
+		config: options.config,
+		envFiles: []
+	});
+	try {
+		const snapshot = await engine.read();
+		followLoaderInputs(context, snapshot);
+		return routesModuleCode(snapshot);
+	} catch (error) {
+		const failure = error instanceof Error ? error : new Error(String(error));
+		const followed = (failure instanceof RoutesReadError ? failure.inputs : void 0) ?? engine.last;
+		if (followed !== void 0) followLoaderInputs(context, followed);
+		const last = engine.last;
+		if (last === void 0 || builds(context)) throw failure;
+		const reported = new Error(`[courier] ${failure.message}`, { cause: failure });
+		if (context.emitError) context.emitError(reported);
+		else console.error(reported.message);
+		return routesModuleCode(last);
+	}
+}
+function builds(context) {
+	return context.mode === void 0 ? process.env.NODE_ENV === "production" : context.mode === "production";
+}
+export { runRoutesLoader };

package/lib/webpack-BPxhBYGV.js

@@ -0,0 +1,42 @@
+import { n as routesProject, r as configInPageRule, t as routesRule } from "./routes-rule-Pu1Tz8Xm.js";
+// src/webpack/courier-routes-plugin.ts
+const SERVER_TARGET = /^(async-)?node|^electron-(main|preload)|^nwjs/;
+/**
+* The webpack and Rspack plugin that builds the routes a page's proxy
+* client may call from `courier.config.ts`, in place of the module
+* `@noverax/courier/routes` ships, for every bundle the compiler builds. No
+* routes file is written, and the routes carry no address, path or
+* middleware. A page's bundle that takes the config itself fails.
+*
+* @example
+* ```ts
+* // webpack.config.js
+* import { CourierRoutesPlugin } from "@noverax/courier-build/webpack";
+*
+* export default { plugins: [new CourierRoutesPlugin()] };
+* ```
+*/
+var CourierRoutesPlugin = class {
+	#options;
+	/**
+	* @param options - Where the config is, when it is not found from the compiler's context
+	*/
+	constructor(options = {}) {
+		this.#options = options;
+	}
+	/**
+	* @param compiler - The compiler the plugin is given
+	*/
+	apply(compiler) {
+		const project = routesProject(compiler.context, this.#options);
+		compiler.options.module.rules ??= [];
+		const rules = compiler.options.module.rules;
+		rules.push(routesRule(project));
+		const guard = configInPageRule(project);
+		if (guard !== void 0 && buildsPage(compiler.options.target)) rules.push(guard);
+	}
+};
+function buildsPage(target) {
+	return !(Array.isArray(target) ? target : [target]).some((one) => typeof one === "string" && SERVER_TARGET.test(one));
+}
+export { CourierRoutesPlugin as t };

package/lib/worker-messages-BT2vvNQJ.js

@@ -0,0 +1,35 @@
+import { n as isRecord } from "./errno-code-CNx_E80R.js";
+// src/engine/worker-messages.ts
+const REQUEST_KIND = "courier-routes-request";
+const REPLY_KIND = "courier-routes-reply";
+/**
+* The messages between the engine and the process that reads the routes,
+* marked and checked, so a message a config or a library sends on the same
+* channel — a readiness signal to a supervisor — is never taken for one.
+*
+* @example
+* ```ts
+* child.send(workerMessages.request(request));
+* child.on("message", (message) => {
+*   if (workerMessages.isReply(message)) settle(message.reply);
+* });
+* ```
+*/
+const workerMessages = {
+	request: (request) => ({
+		kind: REQUEST_KIND,
+		request
+	}),
+	reply: (reply) => ({
+		kind: REPLY_KIND,
+		reply
+	}),
+	isRequest: (message) => isRecord(message) && message.kind === REQUEST_KIND && isRecord(message.request),
+	isReply: (message) => isRecord(message) && message.kind === REPLY_KIND && isWorkerReply(message.reply)
+};
+function isWorkerReply(value) {
+	if (!isRecord(value)) return false;
+	if (value.ok === true) return isRecord(value.snapshot) && isRecord(value.snapshot.routes);
+	return value.ok === false && typeof value.code === "string" && typeof value.message === "string" && isRecord(value.context);
+}
+export { workerMessages as t };

package/package.json

@@ -1,6 +1,211 @@
 {
   "name": "@noverax/courier-build",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.5.0",
+  "description": "Courier at build time: loads courier.config the way every Courier tool does, and hands a page's bundle the routes its proxy client may call through a plugin for the app's bundler, with no routes file to generate",
+  "keywords": [
+    "courier",
+    "vite",
+    "vite-plugin",
+    "rsbuild",
+    "rspack",
+    "webpack",
+    "esbuild",
+    "rollup",
+    "rolldown",
+    "jest",
+    "metro",
+    "expo",
+    "react-native",
+    "bundler",
+    "plugin",
+    "proxy",
+    "routes",
+    "typescript",
+    "type-safe",
+    "api"
+  ],
+  "author": {
+    "name": "NoveraX",
+    "url": "https://github.com/NoveraX"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NoveraX/courier.git",
+    "directory": "packages/build"
+  },
+  "homepage": "https://courier.noverax.cloud/docs/proxy-mode/expose",
+  "bugs": {
+    "url": "https://github.com/NoveraX/courier/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "sideEffects": false,
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./config": {
+      "types": "./lib/config/index.d.ts",
+      "import": "./lib/config/index.js",
+      "default": "./lib/config/index.js"
+    },
+    "./vite": {
+      "types": "./lib/vite/index.d.ts",
+      "import": "./lib/vite/index.js",
+      "default": "./lib/vite/index.js"
+    },
+    "./webpack": {
+      "types": "./lib/webpack/index.d.ts",
+      "import": "./lib/webpack/index.js",
+      "default": "./lib/webpack/index.js"
+    },
+    "./rspack": {
+      "types": "./lib/rspack/index.d.ts",
+      "import": "./lib/rspack/index.js",
+      "default": "./lib/rspack/index.js"
+    },
+    "./rsbuild": {
+      "types": "./lib/rsbuild/index.d.ts",
+      "import": "./lib/rsbuild/index.js",
+      "default": "./lib/rsbuild/index.js"
+    },
+    "./esbuild": {
+      "types": "./lib/esbuild/index.d.ts",
+      "import": "./lib/esbuild/index.js",
+      "default": "./lib/esbuild/index.js"
+    },
+    "./rollup": {
+      "types": "./lib/rollup/index.d.ts",
+      "import": "./lib/rollup/index.js",
+      "default": "./lib/rollup/index.js"
+    },
+    "./jest": {
+      "types": "./lib/jest/transformer.d.cts",
+      "default": "./lib/jest/transformer.cjs"
+    },
+    "./metro": {
+      "import": {
+        "types": "./lib/metro/index.d.ts",
+        "default": "./lib/metro/index.js"
+      },
+      "require": {
+        "types": "./lib/metro/index.d.cts",
+        "default": "./lib/metro/index.cjs"
+      },
+      "default": "./lib/metro/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "config": [
+        "./lib/config/index.d.ts"
+      ],
+      "vite": [
+        "./lib/vite/index.d.ts"
+      ],
+      "webpack": [
+        "./lib/webpack/index.d.ts"
+      ],
+      "rspack": [
+        "./lib/rspack/index.d.ts"
+      ],
+      "rsbuild": [
+        "./lib/rsbuild/index.d.ts"
+      ],
+      "esbuild": [
+        "./lib/esbuild/index.d.ts"
+      ],
+      "rollup": [
+        "./lib/rollup/index.d.ts"
+      ],
+      "jest": [
+        "./lib/jest/transformer.d.cts"
+      ],
+      "metro": [
+        "./lib/metro/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsdown --watch"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "confbox": "^0.3.1",
+    "jiti": "^2.7.0"
+  },
+  "peerDependencies": {
+    "@noverax/courier": "^0.5.0",
+    "@rsbuild/core": ">=1.0.0",
+    "@rspack/core": ">=1.0.0",
+    "esbuild": ">=0.17.0",
+    "jest": ">=29.0.0",
+    "metro": ">=0.80.0",
+    "rolldown": ">=1.0.0",
+    "rollup": ">=3.0.0",
+    "vite": ">=5.0.0",
+    "webpack": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@rsbuild/core": {
+      "optional": true
+    },
+    "@rspack/core": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "jest": {
+      "optional": true
+    },
+    "metro": {
+      "optional": true
+    },
+    "rolldown": {
+      "optional": true
+    },
+    "rollup": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "webpack": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.7",
+    "@babel/plugin-transform-modules-commonjs": "^7.29.7",
+    "@noverax/courier": "*",
+    "@rsbuild/core": "^2.3.1",
+    "@rspack/core": "^2.3.1",
+    "esbuild": "^0.28.2",
+    "jest": "^30.5.2",
+    "metro": "^0.87.2",
+    "metro-config": "^0.87.2",
+    "rolldown": "^1.2.15",
+    "rollup": "^4.65.0",
+    "webpack": "^5.112.2"
+  }
+}