@uxf/resizer 11.125.0 → 11.129.0

package/.resizer-config.json

@@ -1,14 +1,14 @@
 [
     {
-        "route": "/generated/:namespace/:p1/:p2/:filename([a-f0-9\\-]+)_:width(\\d+)_:height(\\d+)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:extension.:toFormat",
-        "source": "/Users/vejvis/UXF/projects/resizer/example-upload/:namespace/:p1/:p2/:filename.:extension"
+        "route": "/generated/:namespace/:p1/:p2/:filename([a-f0-9\\-]+)_:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([0-9a-ft]+)_:trim([a-z]+)_:quality(\\d+|x)_:extension.:toFormat",
+        "source": "/Users/mac/Develop/PhpStormProjects/UXF/fe-monorepo/packages/resizer/example-upload/:namespace/:p1/:p2/:filename.:extension"
     },
     {
         "route": "/generated/:namespace/:p1/:p2/:filename([a-f0-9\\-]+)_:width(\\d+)_:height(\\d+)_:fit([a-z]+).:extension",
-        "source": "/Users/vejvis/UXF/projects/resizer/example-upload/:namespace/:p1/:p2/:filename.:extension"
+        "source": "/Users/mac/Develop/PhpStormProjects/UXF/fe-monorepo/packages/resizer/example-upload/:namespace/:p1/:p2/:filename.:extension"
     },
     {
-        "route": "/generated/static/:width(\\d+)_:height(\\d+)/:filename(*).:extension.:toFormat",
+        "route": "/generated/static/:width(\\d+)_:height(\\d+)/:filename(.*).:extension.:toFormat",
         "source": "https://www.uxf.cz/:filename+.:extension"
     }
 ]

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm](https://img.shields.io/npm/v/@uxf/resizer)](https://www.npmjs.com/package/@uxf/resizer)
 
-On-the-fly image resizing that serves the `/generated/...` URLs produced by `resizerImageUrl` (`@uxf/core`). It ships Next.js App Router route handlers for local development and a standalone Express server (`uxf-resizer`) for self-hosting. Resizing is done with [`sharp`](https://sharp.pixelplumbing.com/).
+On-the-fly image resizing that serves the `/generated/...` URLs produced by `resizerImageUrl` (`@uxf/core`). It ships Next.js App Router route handlers for local development and a standalone HTTP server (`uxf-resizer`, built on [Hono](https://hono.dev/)) for self-hosting. Resizing is done with [`sharp`](https://sharp.pixelplumbing.com/).
 
 ## When to use
 
@@ -10,7 +10,7 @@ This package **serves and generates** resized images. It does **not** build imag
 
 - **Production** — a shared/global resizer service handles the `/generated/...` requests; you typically do not run this package there.
 - **Local development** — mount `ProxyGET` / `StaticGET` as Next.js route handlers so `/generated/...` URLs resolve during `next dev`.
-- **Self-hosting** — run the `uxf-resizer` CLI (Express server) driven by a config file.
+- **Self-hosting** — run the `uxf-resizer` CLI (Hono server on Node) driven by a config file.
 
 Both entry points read the same URL segments (width, height, fit, position, background, trim, quality, target format) and pipe the source image through `sharp`. Generated files are cached on disk and re-served on subsequent requests.
 
@@ -20,12 +20,14 @@ Both entry points read the same URL segments (width, height, fit, position, back
 yarn add @uxf/resizer --dev
 ```
 
-The only runtime dependency is `sharp`. The standalone server additionally needs `express`, `path-to-regexp`, `process`, and `yargs` — they are **not** installed transitively, so add them yourself when you use the CLI:
+The only runtime dependency is `sharp`. The standalone server additionally needs `hono`, `@hono/node-server`, and `yargs` — they are **not** installed transitively, so add them yourself when you use the CLI:
 
 ```
-yarn add @uxf/resizer express path-to-regexp process yargs --dev
+yarn add @uxf/resizer hono @hono/node-server yargs --dev
 ```
 
+Node `>= 24` is required (route matching uses the built-in `URLPattern`).
+
 ## Quick start
 
 Next.js App Router route handlers for local development. Two handlers are exported:
@@ -72,10 +74,10 @@ NEXT_PUBLIC_API_URL=https://uxf.cz               # ProxyGET source (fetches <API
 
 Exported from the package root (`@uxf/resizer`):
 
-| Export | Signature | Description |
-|--------|-----------|-------------|
-| `ProxyGET` | `(request: Request) => Promise<Response>` | Next.js route handler. Matches `/generated/:namespace/:p1/:p2/:filename_..._:extension.:toFormat`, fetches the source from `${NEXT_PUBLIC_API_URL}/upload/:namespace/:p1/:p2/:filename.:extension`, resizes, caches under the process CWD, and returns the image. |
-| `StaticGET` | `(request: Request) => Promise<Response>` | Next.js route handler. Matches `/generated/static/..._:quality/:version/:filename.:extension.:toFormat`. Reads local `public/:filename.:extension`; for `_next/static/media/*` imports it fetches from `${NEXT_PUBLIC_FRONTEND_URL}`. |
+| Export      | Signature                                 | Description                                                                                                                                                                                                                                                       |
+| ----------- | ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ProxyGET`  | `(request: Request) => Promise<Response>` | Next.js route handler. Matches `/generated/:namespace/:p1/:p2/:filename_..._:extension.:toFormat`, fetches the source from `${NEXT_PUBLIC_API_URL}/upload/:namespace/:p1/:p2/:filename.:extension`, resizes, caches under the process CWD, and returns the image. |
+| `StaticGET` | `(request: Request) => Promise<Response>` | Next.js route handler. Matches `/generated/static/..._:quality/:version/:filename.:extension.:toFormat`. Reads local `public/:filename.:extension`; for `_next/static/media/*` imports it fetches from `${NEXT_PUBLIC_FRONTEND_URL}`.                             |
 
 Command-line server:
 
@@ -83,24 +85,24 @@ Command-line server:
 uxf-resizer
 ```
 
-Starts an Express server on port `3000` that applies the routes from the configuration (see below). Requires the extra dependencies listed under Installation.
+Starts a Hono server (via `@hono/node-server`) on port `3000` that applies the routes from the configuration (see below). Requires the extra dependencies listed under Installation. Responses carry `Content-Type`, `Content-Length` and `Last-Modified`; the server does not emit `ETag` and does not handle `Range` or conditional requests — put a cache/CDN in front of it if you need those.
 
 ## Route parameters
 
 The URL segments understood by every route. They are produced by `resizerImageUrl` (`@uxf/core`) and mapped onto [`sharp`](https://sharp.pixelplumbing.com/) options.
 
-| Parameter  | Values                                     | Default (falls back to sharp)          |
-|------------|--------------------------------------------|----------------------------------------|
-| width      | `number` or `x` (auto)                     | `undefined` (auto)                     |
-| height     | `number` or `x` (auto)                     | `undefined` (auto)                     |
-| fit        | fit code (see below)                       | `cover`                                |
-| position   | position code (see below)                  | sharp default (`centre`)               |
-| background | hex (e.g. `FFFFFF`) or `t` (transparent)   | `#<hex>`                               |
-| trim       | `number` (threshold) or `nt` (no trim)     | no trim                                |
-| quality    | `number` (1–100) or `x` (auto)             | sharp default (avif: 50, others: 80)   |
-| toFormat   | `webp`, `png`, `avif`, `jpg`, `svg`        | `jpg`                                  |
+| Parameter  | Values                                   | Default (falls back to sharp)        |
+| ---------- | ---------------------------------------- | ------------------------------------ |
+| width      | `number` or `x` (auto)                   | `undefined` (auto)                   |
+| height     | `number` or `x` (auto)                   | `undefined` (auto)                   |
+| fit        | fit code (see below)                     | `cover`                              |
+| position   | position code (see below)                | sharp default (`centre`)             |
+| background | hex (e.g. `FFFFFF`) or `t` (transparent) | `t` when the route has no segment    |
+| trim       | `number` (threshold) or `nt` (no trim)   | no trim                              |
+| quality    | `number` (1–100) or `x` (auto)           | sharp default (avif: 50, others: 80) |
+| toFormat   | `webp`, `png`, `avif`, `jpg`, `svg`      | `jpg`                                |
 
-`svg` is a passthrough — the source file is copied unchanged, without resizing.
+`svg` is a passthrough — the source file is copied unchanged, without resizing. A route does not have to capture every parameter: a missing `fit`, `position`, `background`, `trim` or `quality` falls back to the default in the table.
 
 ### Fit codes
 
@@ -128,12 +130,17 @@ The URL segments understood by every route. They are produced by `resizerImageUr
 
 The `uxf-resizer` CLI reads its config from `.resizer-config.json` in the working directory, or from the `UXF_RESIZER_CONFIG` environment variable (an inline JSON string, which takes precedence). Generated files are written to `UXF_RESIZER_GENERATE_PATH` (defaults to the process CWD).
 
-The config is an array of `{ route, source }` objects. `route` is a [`path-to-regexp`](https://github.com/pillarjs/path-to-regexp) pattern that captures the resize parameters; `source` is the original file location (a local path or an `http(s)` URL, which is fetched). `source` may reference any captured segment, including the domain as a parameter (e.g. `https://:url/...`).
+The config is an array of `{ route, source }` objects.
+
+- `route` is a [`URLPattern`](https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API) pathname pattern (Node's built-in implementation; the syntax is `path-to-regexp` v6 compatible): `:name`, `:name(regexp)`, several parameters per segment (`:width(\d+)_:height(\d+)`), `:name(.*)` to capture across slashes. Matching is case-insensitive and captured values are percent-decoded. The first matching route wins.
+- `source` is the original file location (a local path or an `http(s)` URL, which is fetched). Every `:name` is replaced by the captured value; a `+`, `*` or `?` suffix is accepted and ignored (`:filename+` and `:filename` are equivalent). The domain may itself be a parameter (`https://:url/...`); a port such as `localhost:3000` is left alone.
+
+The legacy Express form `:filename(*)` is still accepted and rewritten to `:filename(.*)` with a startup warning — update your configs.
 
 ```json
 [
     {
-        "route": "/generated/static/:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)/:version/:filename(*).:extension.:toFormat",
+        "route": "/generated/static/:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)/:version/:filename(.*).:extension.:toFormat",
         "source": "https://static.example.dev/:filename+.:extension"
     },
     {
@@ -152,7 +159,7 @@ Deprecated — use the global resizer for all projects instead.
 ```json
 [
     {
-        "route": "/generated/static/:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)/:version/:filename(*).:extension.:toFormat",
+        "route": "/generated/static/:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)/:version/:filename(.*).:extension.:toFormat",
         "source": "https://uxf-base.uxf.dev/:filename+.:extension"
     },
     {
@@ -165,13 +172,16 @@ Deprecated — use the global resizer for all projects instead.
 ## Gotchas
 
 - **URLs are built elsewhere.** Encode the parameters with `resizerImageUrl` from `@uxf/core/utils/resizer`; this package only serves the resulting paths.
-- **CLI dependencies are not transitive.** `express`, `path-to-regexp`, `process`, and `yargs` are dev dependencies of this package, so a consumer running `uxf-resizer` must install them explicitly.
+- **CLI dependencies are not transitive.** `hono`, `@hono/node-server`, and `yargs` are dev dependencies of this package, so a consumer running `uxf-resizer` must install them explicitly.
+- **Parameters are validated only by the route regexps.** A value that passes the route but is not a known code (an unknown `fit`, a non-numeric `width`) falls back to sharp defaults or makes sharp throw, which is answered with `404`.
 - **Generated files are cached on disk.** Once a variant exists under the output path it is served as-is; delete the cached file to force regeneration.
-- **The server listens on a fixed port `3000`** and an empty or invalid configuration throws on startup.
+- **The server listens on a fixed port `3000`** and an empty or invalid configuration (including a route `URLPattern` cannot parse) throws on startup. `SIGINT`/`SIGTERM` close the server.
 - **`quality` defaults to sharp's own defaults** when set to `x` (avif ≈ 50, others ≈ 80). Values are expected in the `1–100` range.
 
 ## Links
 
 - [npm: @uxf/resizer](https://www.npmjs.com/package/@uxf/resizer)
 - [sharp documentation](https://sharp.pixelplumbing.com/)
+- [Hono](https://hono.dev/) and [`@hono/node-server`](https://github.com/honojs/node-server)
+- [URLPattern API](https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API)
 - URL builder: `resizerImageUrl` in `@uxf/core/utils/resizer`

package/bin/uxf-resizer.js

@@ -37,11 +37,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = __importDefault(require("express"));
+const node_server_1 = require("@hono/node-server");
 const fs = __importStar(require("fs"));
-const process_1 = require("process");
+const hono_1 = require("hono");
+const node_process_1 = require("node:process");
 const yargs_1 = __importDefault(require("yargs"));
-const middleware_1 = require("../src/middleware");
+const handler_1 = require("../src/handler");
+const PORT = 3000;
 const uxfResizer = async () => {
     var _a;
     (0, yargs_1.default)()
@@ -57,31 +59,29 @@ Environment variables:
         .strict(false)
         .exitProcess(false);
     try {
-        const { help } = (0, yargs_1.default)().parse(process_1.argv.slice(2)); // TODO
+        const { help } = (0, yargs_1.default)().parse(node_process_1.argv.slice(2)); // TODO
         if (help) {
             return 0;
         }
         const configFilename = process.cwd() + "/.resizer-config.json";
-        const configString = (_a = process_1.env.UXF_RESIZER_CONFIG) !== null && _a !== void 0 ? _a : (fs.existsSync(configFilename) ? fs.readFileSync(configFilename).toString() : "[]");
+        const configString = (_a = node_process_1.env.UXF_RESIZER_CONFIG) !== null && _a !== void 0 ? _a : (fs.existsSync(configFilename) ? fs.readFileSync(configFilename).toString() : "[]");
         const config = JSON.parse(configString);
         if (!Array.isArray(config) || config.length === 0) {
             throw new Error("Invalid or empty configuration");
         }
-        return new Promise((resolve, reject) => {
-            try {
-                const app = (0, express_1.default)().use((0, middleware_1.resizerMiddleware)(config));
-                const listenedApp = app.listen(3000, () => {
-                    // eslint-disable-next-line no-console
-                    console.log("\nImage resizer app listening on port 3000");
-                    app.on("close", () => {
-                        listenedApp.close();
-                        resolve(true);
-                    });
-                });
-            }
-            catch (e) {
-                reject(e);
-            }
+        const handler = (0, handler_1.createResizerHandler)(config);
+        const app = new hono_1.Hono();
+        app.get("*", (c) => handler(c.req.raw));
+        return new Promise((resolve) => {
+            const server = (0, node_server_1.serve)({ fetch: app.fetch, port: PORT }, () => {
+                // eslint-disable-next-line no-console
+                console.log(`\nImage resizer app listening on port ${PORT}`);
+            });
+            const shutdown = () => {
+                server.close(() => resolve(0));
+            };
+            process.once("SIGINT", shutdown);
+            process.once("SIGTERM", shutdown);
         });
     }
     catch (e) {

package/bin/uxf-resizer.ts

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
-import express from "express";
+import { serve } from "@hono/node-server";
 import * as fs from "fs";
-import { argv, env } from "process";
+import { Hono } from "hono";
+import { argv, env } from "node:process";
 import cli from "yargs";
-import { Config, resizerMiddleware } from "../src/middleware";
+import { Config, createResizerHandler } from "../src/handler";
+
+const PORT = 3000;
 
 const uxfResizer = async () => {
     cli()
@@ -38,22 +41,21 @@ Environment variables:
             throw new Error("Invalid or empty configuration");
         }
 
-        return new Promise((resolve, reject) => {
-            try {
-                const app = express().use(resizerMiddleware(config));
+        const handler = createResizerHandler(config);
+        const app = new Hono();
+        app.get("*", (c) => handler(c.req.raw));
 
-                const listenedApp = app.listen(3000, () => {
-                    // eslint-disable-next-line no-console
-                    console.log("\nImage resizer app listening on port 3000");
+        return new Promise<number>((resolve) => {
+            const server = serve({ fetch: app.fetch, port: PORT }, () => {
+                // eslint-disable-next-line no-console
+                console.log(`\nImage resizer app listening on port ${PORT}`);
+            });
 
-                    app.on("close" as any, () => {
-                        listenedApp.close();
-                        resolve(true);
-                    });
-                });
-            } catch (e) {
-                reject(e);
-            }
+            const shutdown = () => {
+                server.close(() => resolve(0));
+            };
+            process.once("SIGINT", shutdown);
+            process.once("SIGTERM", shutdown);
         });
     } catch (e) {
         // eslint-disable-next-line no-console

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/resizer",
-    "version": "11.125.0",
+    "version": "11.129.0",
     "main": "index.js",
     "description": "UXF Resizer",
     "author": "UXFans <dev@uxf.cz>",
@@ -16,17 +16,12 @@
     },
     "license": "MIT",
     "dependencies": {
-        "sharp": "^0.34.4"
+        "sharp": "^0.35.4"
     },
     "devDependencies": {
-        "@types/express": "4.17.25",
-        "@types/express-serve-static-core": "4.19.9",
+        "@hono/node-server": "2.1.1",
         "@types/node": "24",
-        "concurrently": "10.0.4",
-        "crypto-js": "4.2.0",
-        "express": "4.22.2",
-        "path-to-regexp": "6.2.2",
-        "process": "0.11.10",
+        "hono": "4.13.7",
         "tsx": "4.23.12",
         "yargs": "18.1.0"
     },

package/src/handler.d.ts

@@ -0,0 +1,10 @@
+export type Config = Array<{
+    route: string;
+    source: string;
+}>;
+/**
+ * Builds a framework-agnostic request handler for the configured routes: the same `Request -> Response`
+ * shape the Next.js route handlers use, so it can sit behind Hono, `@hono/node-server`, or any other
+ * WHATWG-fetch-compatible server.
+ */
+export declare function createResizerHandler(config: Config): (request: Request) => Promise<Response>;

package/src/handler.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResizerHandler = createResizerHandler;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const get_source_filename_1 = require("./utils/get-source-filename");
+const image_converter_1 = require("./utils/image-converter");
+const log_1 = require("./utils/log");
+const match_route_1 = require("./utils/match-route");
+const tools_1 = require("./utils/tools");
+function matchRoute(routes, pathname) {
+    for (const route of routes) {
+        const params = route.match(pathname);
+        if (params !== undefined) {
+            return { params, source: route.source };
+        }
+    }
+    return undefined;
+}
+async function fileResponse(filename, contentType) {
+    const [data, stats] = await Promise.all([(0, promises_1.readFile)(filename), (0, promises_1.stat)(filename)]);
+    return new Response(data, {
+        headers: {
+            "Content-Type": contentType,
+            "Content-Length": String(stats.size),
+            "Last-Modified": stats.mtime.toUTCString(),
+        },
+    });
+}
+async function fetchSource(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Source ${url} responded with ${response.status}`);
+    }
+    return response.arrayBuffer();
+}
+/**
+ * Builds a framework-agnostic request handler for the configured routes: the same `Request -> Response`
+ * shape the Next.js route handlers use, so it can sit behind Hono, `@hono/node-server`, or any other
+ * WHATWG-fetch-compatible server.
+ */
+function createResizerHandler(config) {
+    const routes = config.map((c, i) => {
+        (0, log_1.log)(`Config #${i + 1}:`);
+        (0, log_1.log)(`    Route:  ${c.route}`);
+        (0, log_1.log)(`    Source: ${c.source}`);
+        return { match: (0, match_route_1.createRouteMatcher)(c.route), source: c.source };
+    });
+    return async (request) => {
+        var _a, _b;
+        try {
+            const { pathname } = new URL(request.url);
+            (0, log_1.log)("----------------------------------------");
+            (0, log_1.log)(`${request.method} ${pathname}`);
+            const matched = matchRoute(routes, pathname);
+            if (matched === undefined) {
+                (0, log_1.log)("No route matched", "warn");
+                return new Response("Not Found", { status: 404 });
+            }
+            const { params, source } = matched;
+            const generatedFilename = ((_a = process.env.UXF_RESIZER_GENERATE_PATH) !== null && _a !== void 0 ? _a : process.cwd()) + pathname;
+            (0, log_1.log)(`Generated filename: ${generatedFilename}`);
+            const contentType = params.toFormat === "svg" ? "image/svg+xml" : ((_b = tools_1.CONTENT_TYPES[params.toFormat]) !== null && _b !== void 0 ? _b : "image/jpeg");
+            if ((0, fs_1.existsSync)(generatedFilename)) {
+                return await fileResponse(generatedFilename, contentType);
+            }
+            await (0, promises_1.mkdir)((0, path_1.dirname)(generatedFilename), { recursive: true });
+            const sourceFilename = (0, get_source_filename_1.getSourceFilename)(source, params);
+            (0, log_1.log)(`Source filename:    ${sourceFilename}`);
+            const isRemote = /^https?:\/\//.test(sourceFilename);
+            if (params.toFormat === "svg") {
+                if (isRemote) {
+                    await (0, promises_1.writeFile)(generatedFilename, Buffer.from(await fetchSource(sourceFilename)));
+                }
+                else {
+                    await (0, promises_1.copyFile)(sourceFilename, generatedFilename);
+                }
+                return await fileResponse(generatedFilename, contentType);
+            }
+            const sourceFile = isRemote ? await fetchSource(sourceFilename) : sourceFilename;
+            await (0, image_converter_1.convertImage)(sourceFile, generatedFilename, params);
+            return await fileResponse(generatedFilename, contentType);
+        }
+        catch (e) {
+            (0, log_1.log)(e, "error");
+            return new Response("Not Found", { status: 404 });
+        }
+    };
+}

package/src/handler.test.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @jest-environment node
+ */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const sharp_1 = __importDefault(require("sharp"));
+const handler_1 = require("./handler");
+const STATIC_ROUTE = "/generated/static/:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z0-9]+)_:trim([a-z0-9]+)_:quality(\\d+|x)/:version/:filename(.*).:extension.:toFormat";
+let workDir;
+let sourceDir;
+let generatePath;
+let handler;
+let logSpy;
+beforeAll(async () => {
+    workDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), "uxf-resizer-"));
+    sourceDir = (0, path_1.join)(workDir, "source");
+    generatePath = (0, path_1.join)(workDir, "generated");
+    process.env.UXF_RESIZER_GENERATE_PATH = generatePath;
+    (0, fs_1.mkdirSync)(sourceDir, { recursive: true });
+    await (0, sharp_1.default)({ create: { width: 40, height: 20, channels: 3, background: "#ff0000" } })
+        .png()
+        .toFile((0, path_1.join)(sourceDir, "img.png"));
+    const config = [{ route: STATIC_ROUTE, source: `${sourceDir}/:filename+.:extension` }];
+    logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
+    handler = (0, handler_1.createResizerHandler)(config);
+});
+afterAll(() => {
+    logSpy.mockRestore();
+    delete process.env.UXF_RESIZER_GENERATE_PATH;
+    (0, fs_1.rmSync)(workDir, { recursive: true, force: true });
+});
+test("generates, caches and serves a resized image", async () => {
+    const path = "/generated/static/20_x_cv_c_FFF_nt_x/1/img.png.webp";
+    const response = await handler(new Request(`http://localhost${path}`));
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe("image/webp");
+    expect(response.headers.get("Last-Modified")).toBeTruthy();
+    expect((0, fs_1.existsSync)(generatePath + path)).toBe(true);
+    const body = await response.arrayBuffer();
+    expect(response.headers.get("Content-Length")).toBe(String(body.byteLength));
+    const metadata = await (0, sharp_1.default)(Buffer.from(body)).metadata();
+    expect(metadata.format).toBe("webp");
+    expect(metadata.width).toBe(20);
+    // second request is served from the cache – same file, same headers
+    const cached = await handler(new Request(`http://localhost${path}?ignored=1`));
+    expect(cached.status).toBe(200);
+    expect(cached.headers.get("Content-Length")).toBe(response.headers.get("Content-Length"));
+});
+test("responds 404 for an unmatched path", async () => {
+    const response = await handler(new Request("http://localhost/generated/nonsense"));
+    expect(response.status).toBe(404);
+});
+test("responds 404 when the source file is missing", async () => {
+    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+    const response = await handler(new Request("http://localhost/generated/static/20_x_cv_c_FFF_nt_x/1/missing.png.webp"));
+    expect(response.status).toBe(404);
+    expect(errorSpy).toHaveBeenCalled();
+    errorSpy.mockRestore();
+});

package/src/handler.test.ts

@@ -0,0 +1,79 @@
+/**
+ * @jest-environment node
+ */
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import sharp from "sharp";
+import { Config, createResizerHandler } from "./handler";
+
+const STATIC_ROUTE =
+    "/generated/static/:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z0-9]+)_:trim([a-z0-9]+)_:quality(\\d+|x)/:version/:filename(.*).:extension.:toFormat";
+
+let workDir: string;
+let sourceDir: string;
+let generatePath: string;
+let handler: (request: Request) => Promise<Response>;
+let logSpy: jest.SpyInstance;
+
+beforeAll(async () => {
+    workDir = mkdtempSync(join(tmpdir(), "uxf-resizer-"));
+    sourceDir = join(workDir, "source");
+    generatePath = join(workDir, "generated");
+    process.env.UXF_RESIZER_GENERATE_PATH = generatePath;
+
+    mkdirSync(sourceDir, { recursive: true });
+    await sharp({ create: { width: 40, height: 20, channels: 3, background: "#ff0000" } })
+        .png()
+        .toFile(join(sourceDir, "img.png"));
+
+    const config: Config = [{ route: STATIC_ROUTE, source: `${sourceDir}/:filename+.:extension` }];
+    logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
+    handler = createResizerHandler(config);
+});
+
+afterAll(() => {
+    logSpy.mockRestore();
+    delete process.env.UXF_RESIZER_GENERATE_PATH;
+    rmSync(workDir, { recursive: true, force: true });
+});
+
+test("generates, caches and serves a resized image", async () => {
+    const path = "/generated/static/20_x_cv_c_FFF_nt_x/1/img.png.webp";
+
+    const response = await handler(new Request(`http://localhost${path}`));
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe("image/webp");
+    expect(response.headers.get("Last-Modified")).toBeTruthy();
+    expect(existsSync(generatePath + path)).toBe(true);
+
+    const body = await response.arrayBuffer();
+    expect(response.headers.get("Content-Length")).toBe(String(body.byteLength));
+
+    const metadata = await sharp(Buffer.from(body)).metadata();
+    expect(metadata.format).toBe("webp");
+    expect(metadata.width).toBe(20);
+
+    // second request is served from the cache – same file, same headers
+    const cached = await handler(new Request(`http://localhost${path}?ignored=1`));
+    expect(cached.status).toBe(200);
+    expect(cached.headers.get("Content-Length")).toBe(response.headers.get("Content-Length"));
+});
+
+test("responds 404 for an unmatched path", async () => {
+    const response = await handler(new Request("http://localhost/generated/nonsense"));
+
+    expect(response.status).toBe(404);
+});
+
+test("responds 404 when the source file is missing", async () => {
+    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+    const response = await handler(
+        new Request("http://localhost/generated/static/20_x_cv_c_FFF_nt_x/1/missing.png.webp"),
+    );
+
+    expect(response.status).toBe(404);
+    expect(errorSpy).toHaveBeenCalled();
+    errorSpy.mockRestore();
+});