html-render-webpack-plugin 0.0.0-feat-dx-followups-20261021095350

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2018 Jahred Hope
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,464 @@
+# html-render-webpack-plugin
+
+[![npm](https://img.shields.io/npm/v/html-render-webpack-plugin.svg)](https://www.npmjs.com/package/html-render-webpack-plugin)
+
+Render HTML files with JavaScript during a webpack build.
+
+- Supports [multiple configurations](https://webpack.js.org/configuration/configuration-types/#exporting-multiple-configurations)
+- Supports [code-splitting](https://webpack.js.org/guides/code-splitting/) and [dynamic imports](https://webpack.js.org/guides/code-splitting/#dynamic-imports)
+- Renders every route to a static file, or on demand through an Express dev router
+- Passes client build stats into the renderer so hashed asset names are correct
+
+## Requirements
+
+- Node >= 22.13
+- webpack ^5.0.0
+- Express >= 4, only if you use `createDevRouter`
+
+## Install
+
+```bash
+pnpm add webpack html-render-webpack-plugin
+# Only needed for the development server:
+pnpm add express
+```
+
+Express is an optional peer dependency. Build-only usage does not require it.
+The published type declarations include the Express request and router types, so
+TypeScript users do not need to install `@types/express` separately.
+
+## Quick start
+
+A single webpack compilation can render HTML when it targets Node and exports a
+function. This is the smallest useful setup.
+
+**src/render.js**
+
+```js
+export default function render({ route }) {
+  return `<!doctype html>
+<html lang="en">
+  <body>
+    <h1>Rendered ${route}</h1>
+  </body>
+</html>`;
+}
+```
+
+**webpack.config.js**
+
+```js
+import path from "node:path";
+
+import { HtmlRenderPlugin } from "html-render-webpack-plugin";
+
+const htmlRenderPlugin = new HtmlRenderPlugin({
+  routes: ["/"],
+  renderDirectory: path.resolve("dist"),
+});
+
+export default {
+  name: "render",
+  target: "node",
+  mode: "production",
+  entry: path.resolve("src/render.js"),
+  output: {
+    // Keep the Node renderer out of the folder you deploy.
+    path: path.resolve(".render"),
+    filename: "render.js",
+    // The plugin evaluates the default export, so expose it as a UMD2 module.
+    library: { type: "umd2", export: "default" },
+  },
+  plugins: [htmlRenderPlugin.rendererPlugin],
+};
+```
+
+The build writes `dist/index.html`. The renderer bundle is written to
+`.render/` and is not part of the static site.
+
+CommonJS configs can use:
+
+```js
+const { HtmlRenderPlugin } = require("html-render-webpack-plugin");
+```
+
+## Multiple configurations
+
+Use two compilations when the renderer needs information from a browser build,
+such as a hashed script filename.
+
+Add `htmlRenderPlugin.statsCollectorPlugin` to every compilation whose stats the
+renderer needs. Add `htmlRenderPlugin.rendererPlugin` to the compilation that
+renders HTML.
+
+**webpack.config.js**
+
+```js
+import path from "node:path";
+
+import {
+  HtmlRenderPlugin,
+  getEntrypointScriptUrls,
+} from "html-render-webpack-plugin";
+
+const htmlRenderPlugin = new HtmlRenderPlugin({
+  routes: ["/", "/about"],
+  renderDirectory: path.resolve("dist"),
+  // Keep the renderer boundary small: pass URLs, not the whole stats object.
+  mapStatsToParams: ({ webpackStats }) => ({
+    scripts: getEntrypointScriptUrls(webpackStats),
+  }),
+});
+
+export default [
+  {
+    name: "client",
+    target: "web",
+    mode: "production",
+    entry: path.resolve("src/client.js"),
+    output: {
+      path: path.resolve("dist"),
+      filename: "assets/[name].[contenthash].js",
+      chunkFilename: "assets/[name].[contenthash].js",
+      publicPath: "/",
+    },
+    plugins: [htmlRenderPlugin.statsCollectorPlugin],
+  },
+  {
+    name: "render",
+    target: "node",
+    mode: "production",
+    // Optional: the plugin already waits for every compilation. Declaring the
+    // dependency makes the intended build order explicit.
+    dependencies: ["client"],
+    entry: path.resolve("src/render.js"),
+    output: {
+      path: path.resolve(".render"),
+      filename: "[name].js",
+      library: { type: "umd2", export: "default" },
+    },
+    plugins: [htmlRenderPlugin.rendererPlugin],
+  },
+];
+```
+
+**src/render.js**
+
+```js
+export default function render({ route, scripts }) {
+  return `<!doctype html>
+<html lang="en">
+  <body>
+    <div id="app">Rendered ${route}</div>
+    ${scripts
+      .map((src) => `<script src="${src}" defer></script>`)
+      .join("\n    ")}
+  </body>
+</html>`;
+}
+```
+
+`getEntrypointScriptUrls(webpackStats, entrypoint = "main")` returns public URLs
+for the JavaScript assets of an entrypoint. It handles hashed filenames,
+`publicPath` values with or without a trailing slash, string assets and asset
+objects. It accepts the stats of a single client compilation and the multi
+compilation stats produced when several compilations use
+`statsCollectorPlugin`. An unknown entrypoint name throws instead of returning an
+empty list.
+
+If you need more control, `mapStatsToParams` receives the route and the client
+stats, and whatever it returns is merged into the renderer's parameters.
+
+## Routes
+
+`routes` accepts strings or objects. A `route` may start with or without a
+leading slash. Paths are appended with `index.html` unless they already end in
+`.html`.
+
+```js
+const routes = [
+  "/", // dist/index.html
+  "/about", // dist/about/index.html
+  "contact", // dist/contact/index.html
+  { route: "/blog/hello", title: "Hello", category: "news" },
+];
+```
+
+Extra keys on a route object are passed to the renderer, which makes routes a
+convenient place for page metadata:
+
+```js
+new HtmlRenderPlugin({
+  routes: [
+    { route: "/", title: "Home", description: "Welcome" },
+    { route: "/about", title: "About", description: "How it works" },
+  ],
+  // mapStatsToParams also receives the route:
+  mapStatsToParams: ({ title, webpackStats }) => ({
+    title,
+    scripts: getEntrypointScriptUrls(webpackStats),
+  }),
+});
+```
+
+The renderer receives `{ route, title, scripts, webpackStats, ... }` depending on
+what `mapStatsToParams` returns.
+
+## Options
+
+### `routes`
+
+**Default:** `[""]`
+
+Routes to render. A file is created for each route. `""` and `"/"` both render
+to `index.html`.
+
+### `renderEntry`
+
+**Default:** `"main"`
+
+The webpack entry in the renderer compilation. Set this when the renderer uses
+[object entry syntax](https://webpack.js.org/concepts/entry-points/#object-syntax).
+
+```js
+new HtmlRenderPlugin({ renderEntry: "myRender" });
+```
+
+### `renderDirectory`
+
+**Default:** `"dist"`
+
+The directory to write HTML files to, resolved from the current working
+directory. This can differ from the renderer compilation's `output.path`; that
+is the recommended setup, so the Node renderer bundle is not deployed with the
+static site.
+
+### `mapStatsToParams`
+
+**Default:** `({ webpackStats }) => ({ webpackStats: webpackStats.toJson() })`
+
+Builds the values passed to the render function for each route. The function
+receives the route fields plus `webpackStats`, and its return value is merged
+into the render parameters.
+
+Prefer passing only what the renderer needs:
+
+```js
+mapStatsToParams: ({ webpackStats }) => ({
+  scripts: getEntrypointScriptUrls(webpackStats),
+});
+```
+
+In a single-compilation setup the renderer's own stats are used. If you do not
+need stats at all, return an empty object:
+
+```js
+mapStatsToParams: () => ({});
+```
+
+### `transformFilePath`
+
+**Default:** `(route) => route.route`
+
+Changes the output path for a route.
+
+```js
+new HtmlRenderPlugin({
+  routes: [
+    { route: "/about", language: "en-us" },
+    { route: "/about", language: "en-au" },
+  ],
+  transformFilePath: ({ route, language }) => `${language}${route}`,
+});
+```
+
+This writes `en-us/about/index.html` and `en-au/about/index.html`.
+
+### `renderConcurrency`
+
+**Default:** `"serial"`
+
+Use `"parallel"` when renders do a lot of asynchronous work.
+
+```js
+new HtmlRenderPlugin({ renderConcurrency: "parallel" });
+```
+
+### `skipAssets`
+
+**Default:** `false`
+
+When `true`, routes are not rendered to files after the build. Use this in watch
+mode with `createDevRouter` or `renderWhenReady`, where pages are rendered on
+demand.
+
+### `transformExpressPath`
+
+**Default:** `(route) => route.route`
+
+Changes the path used by the dev router. Routes are normalized to a leading
+slash, so `"about"` and `"/about"` both work. The default `""` route is served
+at `/`. Return `undefined` to exclude a route from the dev router; an empty
+string excludes every route except the default one.
+
+```js
+new HtmlRenderPlugin({
+  transformExpressPath: (route) =>
+    route.route === "/draft" ? undefined : `/static${route.route}`,
+});
+```
+
+### `getRouteFromRequest`
+
+Used by the dev router to choose a route for a request. It must return one of the
+configured routes, or `undefined` to pass the request to the next middleware.
+
+```js
+new HtmlRenderPlugin({
+  routes: [
+    { route: "/books/1", id: "1" },
+    { route: "/books/2", id: "2" },
+  ],
+  getRouteFromRequest: (req, routes) =>
+    routes.find((route) => route.id === req.params.id),
+});
+```
+
+### `extraGlobals`
+
+Extra values to expose as free variables in the evaluated renderer bundle. Names
+must be valid JavaScript identifiers and cannot be `exports`, `require`,
+`module`, `__filename` or `__dirname`.
+
+## Development server
+
+The dev router renders configured routes on demand with the same renderer bundle
+used by the production build. Use it with Express and
+[`webpack-dev-middleware`](https://github.com/webpack/webpack-dev-middleware) so
+client assets are served from memory.
+
+Set `skipAssets: true` on the plugin when using the dev router. Share the same
+plugin instance between the webpack configuration and the server.
+
+**webpack.config.js**
+
+```js
+export const htmlRenderPlugin = new HtmlRenderPlugin({
+  routes: ["/", "/about"],
+  skipAssets: true,
+});
+```
+
+**dev-server.js**
+
+```js
+import express from "express";
+import webpack from "webpack";
+import devMiddleware from "webpack-dev-middleware";
+
+import config, { htmlRenderPlugin } from "./webpack.config.js";
+
+const compiler = webpack(config);
+const app = express();
+
+// Mount the renderer first, then serve client assets from webpack.
+app.use(htmlRenderPlugin.createDevRouter());
+app.use(devMiddleware(compiler, { publicPath: "/" }));
+
+app.listen(3000, () => {
+  console.log("http://localhost:3000");
+});
+```
+
+If you use webpack-dev-server v5 instead, mount the router in
+`setupMiddlewares`:
+
+```js
+devServer: {
+  setupMiddlewares(middlewares, devServer) {
+    devServer.app.use(htmlRenderPlugin.createDevRouter());
+    return middlewares;
+  },
+}
+```
+
+The dev router does not add hot module replacement. It rerenders a route when it
+is requested after a rebuild.
+
+## Just-in-time rendering
+
+`renderWhenReady` renders any route using the same renderer. It waits until the
+build is ready, so it is safe to call during startup.
+
+```js
+app.get("/books/:id", (req, res) => {
+  res.send(await htmlRenderPlugin.renderWhenReady({ route: "/books/_id" }));
+});
+```
+
+Only use routes that also exist in the production build. Errors contain a
+`webpackStats` property when stats are available.
+
+## Output layout
+
+A typical multi-compilation project looks like this:
+
+```text
+dist/                     # deploy this
+  index.html
+  about/index.html
+  assets/main.<hash>.js
+  assets/<chunk>.<hash>.js
+.render/                  # renderer bundle, do not deploy
+  render.js
+```
+
+Keep the renderer output outside `renderDirectory`. Avoid `output.clean` across
+compilations that share an output directory; clean the directories yourself
+before the build instead.
+
+## TypeScript
+
+The package ships declarations and exports the public option and route types:
+
+```ts
+import {
+  HtmlRenderPlugin,
+  getEntrypointScriptUrls,
+  type BaseRoute,
+  type MapStatsToParams,
+  type Options,
+} from "html-render-webpack-plugin";
+
+interface Route extends BaseRoute {
+  title: string;
+}
+
+const mapStatsToParams: MapStatsToParams<Route> = ({
+  route,
+  title,
+  webpackStats,
+}) => ({
+  route,
+  title,
+  scripts: getEntrypointScriptUrls(webpackStats),
+});
+
+const options: Options<Route> = {
+  routes: [{ route: "/", title: "Home" }],
+  mapStatsToParams,
+};
+
+const plugin = new HtmlRenderPlugin<Route>(options);
+```
+
+## Examples
+
+The fixtures under [`tests/test-cases`](./tests/test-cases) are complete,
+buildable examples, including single and multi-compilation setups, a dev server,
+route metadata and asynchronous rendering.
+
+## Migration
+
+Upgrading from v1? See the
+[v1 to v2 migration guide](./MIGRATION_GUIDE_v1_to_v2.md).

package/dist/RenderError.d.ts

@@ -0,0 +1,3 @@
+export default class RenderError extends Error {
+    constructor(error: Error);
+}

package/dist/RenderError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RenderError extends Error {
+    constructor(error) {
+        super(`html-render-webpack-plugin: An error occurred during render: \n${error}`);
+        this.name = "RenderError";
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.default = RenderError;
+//# sourceMappingURL=RenderError.js.map

package/dist/RenderError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderError.js","sourceRoot":"","sources":["../src/RenderError.ts"],"names":[],"mappings":";;AAAA,MAAqB,WAAY,SAAQ,KAAK;IAC5C,YAAY,KAAY;QACtB,KAAK,CACH,kEAAkE,KAAK,EAAE,CAC1E,CAAC;QAEF,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAE1B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAVD,8BAUC"}

package/dist/assets.d.ts

@@ -0,0 +1,46 @@
+import type { WebpackStats } from "./common-types";
+interface StatsAssetLike {
+    name?: string;
+}
+export interface WebpackStatsJson {
+    entrypoints?: Record<string, {
+        assets?: Array<string | StatsAssetLike>;
+    } | undefined>;
+    publicPath?: string;
+    /** Present on the object returned by `MultiStats.toJson()`. */
+    children?: WebpackStatsJson[];
+}
+/**
+ * The parts of `webpack.MultiStats` this module uses. webpack does not export a
+ * public type for `MultiStats`.
+ */
+export interface MultiStatsLike {
+    toJson(options?: unknown): WebpackStatsJson | WebpackStatsJson[];
+}
+type StatsJsonInput = WebpackStatsJson | WebpackStatsJson[];
+/**
+ * Get the public URLs of the JavaScript assets for one entrypoint.
+ *
+ * Accepts a single stats JSON object or an array of them. The object returned
+ * by `MultiStats.toJson()` for builds with more than one client compilation is
+ * supported through its `children` array.
+ *
+ * Pass `undefined` as the entrypoint to collect scripts from every entrypoint,
+ * which is useful for an error page that does not know which client entry failed.
+ * An unknown entrypoint name throws rather than returning an empty list.
+ */
+export declare function getScriptUrlsFromStats(stats: StatsJsonInput, entrypoint?: string): string[];
+/**
+ * Get the public URLs of the JavaScript assets for an entrypoint.
+ *
+ * This is the common bridge from client stats to a renderer: the renderer can
+ * emit script tags without receiving the whole webpack stats object. It works
+ * for a single client compilation and for multiple client compilations.
+ *
+ * @example
+ * mapStatsToParams: ({ webpackStats }) => ({
+ *   scripts: getEntrypointScriptUrls(webpackStats, "main"),
+ * })
+ */
+export declare function getEntrypointScriptUrls(webpackStats: WebpackStats | MultiStatsLike, entrypoint?: string): string[];
+export {};

package/dist/assets.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScriptUrlsFromStats = getScriptUrlsFromStats;
+exports.getEntrypointScriptUrls = getEntrypointScriptUrls;
+function getStatsList(stats) {
+    if (Array.isArray(stats)) {
+        return stats;
+    }
+    if (stats.children && stats.children.length > 0) {
+        return stats.children;
+    }
+    return [stats];
+}
+function getAssetName(asset) {
+    return typeof asset === "string" ? asset : asset.name;
+}
+function getPublicPath(stats) {
+    return typeof stats.publicPath === "string" && stats.publicPath !== "auto"
+        ? stats.publicPath
+        : "/";
+}
+function joinPublicPath(publicPath, assetName) {
+    const base = publicPath === "" || publicPath.endsWith("/")
+        ? publicPath
+        : `${publicPath}/`;
+    return `${base}${assetName.replace(/^\/+/, "")}`;
+}
+function getAssetNames(stats, entrypoint) {
+    var _a;
+    const entrypoints = (_a = stats.entrypoints) !== null && _a !== void 0 ? _a : {};
+    const groups = entrypoint === undefined
+        ? Object.values(entrypoints)
+        : [entrypoints[entrypoint]];
+    return groups
+        .flatMap((group) => { var _a; return (_a = group === null || group === void 0 ? void 0 : group.assets) !== null && _a !== void 0 ? _a : []; })
+        .map(getAssetName)
+        .filter((name) => typeof name === "string" && name.endsWith(".js"));
+}
+function assertEntrypointExists(statsList, entrypoint) {
+    const available = new Set(statsList.flatMap((stats) => { var _a; return Object.keys((_a = stats.entrypoints) !== null && _a !== void 0 ? _a : {}); }));
+    if (!available.has(entrypoint)) {
+        const known = available.size > 0 ? [...available].join(", ") : "none";
+        throw new Error(`Unable to find entrypoint "${entrypoint}" in webpack stats. Available entrypoints: ${known}.`);
+    }
+}
+/**
+ * Get the public URLs of the JavaScript assets for one entrypoint.
+ *
+ * Accepts a single stats JSON object or an array of them. The object returned
+ * by `MultiStats.toJson()` for builds with more than one client compilation is
+ * supported through its `children` array.
+ *
+ * Pass `undefined` as the entrypoint to collect scripts from every entrypoint,
+ * which is useful for an error page that does not know which client entry failed.
+ * An unknown entrypoint name throws rather than returning an empty list.
+ */
+function getScriptUrlsFromStats(stats, entrypoint) {
+    const statsList = getStatsList(stats);
+    if (entrypoint !== undefined) {
+        assertEntrypointExists(statsList, entrypoint);
+    }
+    const urls = statsList.flatMap((statsJson) => {
+        const publicPath = getPublicPath(statsJson);
+        return getAssetNames(statsJson, entrypoint).map((name) => joinPublicPath(publicPath, name));
+    });
+    return [...new Set(urls)];
+}
+/**
+ * Get the public URLs of the JavaScript assets for an entrypoint.
+ *
+ * This is the common bridge from client stats to a renderer: the renderer can
+ * emit script tags without receiving the whole webpack stats object. It works
+ * for a single client compilation and for multiple client compilations.
+ *
+ * @example
+ * mapStatsToParams: ({ webpackStats }) => ({
+ *   scripts: getEntrypointScriptUrls(webpackStats, "main"),
+ * })
+ */
+function getEntrypointScriptUrls(webpackStats, entrypoint = "main") {
+    const statsJson = webpackStats.toJson({
+        all: false,
+        entrypoints: true,
+        publicPath: true,
+    });
+    return getScriptUrlsFromStats(statsJson, entrypoint);
+}
+//# sourceMappingURL=assets.js.map

package/dist/assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.js","sourceRoot":"","sources":["../src/assets.ts"],"names":[],"mappings":"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"}

package/dist/common-types.d.ts

@@ -0,0 +1,27 @@
+import type * as originalFs from "fs";
+import type { Request } from "express";
+import type { Stats } from "webpack";
+export type WebpackStats = Stats;
+export type BaseRoute = {
+    route: string;
+};
+export type Render<Route = BaseRoute> = (route: Route) => Promise<string>;
+export type OnRendererReady<Route = BaseRoute> = (callback: (render: Render<Route>) => Promise<void>) => void;
+export type Renderer = (...params: any[]) => Promise<string>;
+export type SourceModules = Record<string, string>;
+export type RouteInput<Route = BaseRoute> = Route | string;
+export type Trace = (...values: any[]) => void;
+export type Specifier = string;
+export type ExtraGlobals = Record<string, unknown>;
+export type RenderConcurrency = "parallel" | "serial";
+export type MapStatsToParams<Route extends BaseRoute = BaseRoute> = (params: {
+    webpackStats: WebpackStats;
+} & Route) => Record<string, unknown>;
+export type TransformPath<Route = BaseRoute> = (route: Route) => string;
+/**
+ * Build the Express path for a route. Paths are normalized to a leading slash.
+ * Return `undefined` to exclude a route from the dev router.
+ */
+export type TransformExpressPath<Route = BaseRoute> = (route: Route) => string | undefined;
+export type GetRouteFromRequest<Route> = (req: Request, routes: Route[]) => Route | undefined;
+export type FileSystem = typeof originalFs;

package/dist/common-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=common-types.js.map

package/dist/common-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../src/common-types.ts"],"names":[],"mappings":""}

package/dist/createDevRouter.d.ts

@@ -0,0 +1,11 @@
+import type { Router } from "express";
+import { OnRendererReady, BaseRoute, WebpackStats, TransformExpressPath, GetRouteFromRequest } from "./common-types";
+interface Params<Route> {
+    routes: Route[];
+    getRouteFromRequest?: GetRouteFromRequest<Route>;
+    onRendererReady: OnRendererReady<Route>;
+    transformExpressPath: TransformExpressPath<Route>;
+    getClientStats: () => WebpackStats;
+}
+declare const _default: <Route extends BaseRoute>({ routes, getRouteFromRequest, onRendererReady, transformExpressPath, getClientStats, }: Params<Route>) => Router;
+export = _default;