@uxf/resizer 11.125.0 → 11.129.0

package/src/handler.ts

@@ -0,0 +1,121 @@
+import { existsSync } from "fs";
+import { copyFile, mkdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { getSourceFilename } from "./utils/get-source-filename";
+import { convertImage } from "./utils/image-converter";
+import { log } from "./utils/log";
+import { createRouteMatcher } from "./utils/match-route";
+import { CONTENT_TYPES, Params } from "./utils/tools";
+
+export type Config = Array<{
+    route: string;
+    source: string;
+}>;
+
+interface CompiledRoute {
+    match: (pathname: string) => Params | undefined;
+    source: string;
+}
+
+interface MatchedRoute {
+    params: Params;
+    source: string;
+}
+
+function matchRoute(routes: CompiledRoute[], pathname: string): MatchedRoute | undefined {
+    for (const route of routes) {
+        const params = route.match(pathname);
+        if (params !== undefined) {
+            return { params, source: route.source };
+        }
+    }
+
+    return undefined;
+}
+
+async function fileResponse(filename: string, contentType: string): Promise<Response> {
+    const [data, stats] = await Promise.all([readFile(filename), stat(filename)]);
+
+    return new Response(data, {
+        headers: {
+            "Content-Type": contentType,
+            "Content-Length": String(stats.size),
+            "Last-Modified": stats.mtime.toUTCString(),
+        },
+    });
+}
+
+async function fetchSource(url: string): Promise<ArrayBuffer> {
+    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.
+ */
+export function createResizerHandler(config: Config): (request: Request) => Promise<Response> {
+    const routes = config.map((c, i): CompiledRoute => {
+        log(`Config #${i + 1}:`);
+        log(`    Route:  ${c.route}`);
+        log(`    Source: ${c.source}`);
+
+        return { match: createRouteMatcher(c.route), source: c.source };
+    });
+
+    return async (request) => {
+        try {
+            const { pathname } = new URL(request.url);
+            log("----------------------------------------");
+            log(`${request.method} ${pathname}`);
+
+            const matched = matchRoute(routes, pathname);
+            if (matched === undefined) {
+                log("No route matched", "warn");
+                return new Response("Not Found", { status: 404 });
+            }
+
+            const { params, source } = matched;
+
+            const generatedFilename = (process.env.UXF_RESIZER_GENERATE_PATH ?? process.cwd()) + pathname;
+            log(`Generated filename: ${generatedFilename}`);
+
+            const contentType =
+                params.toFormat === "svg" ? "image/svg+xml" : (CONTENT_TYPES[params.toFormat] ?? "image/jpeg");
+
+            if (existsSync(generatedFilename)) {
+                return await fileResponse(generatedFilename, contentType);
+            }
+
+            await mkdir(dirname(generatedFilename), { recursive: true });
+
+            const sourceFilename = getSourceFilename(source, params);
+            log(`Source filename:    ${sourceFilename}`);
+
+            const isRemote = /^https?:\/\//.test(sourceFilename);
+
+            if (params.toFormat === "svg") {
+                if (isRemote) {
+                    await writeFile(generatedFilename, Buffer.from(await fetchSource(sourceFilename)));
+                } else {
+                    await copyFile(sourceFilename, generatedFilename);
+                }
+
+                return await fileResponse(generatedFilename, contentType);
+            }
+
+            const sourceFile = isRemote ? await fetchSource(sourceFilename) : sourceFilename;
+            await convertImage(sourceFile, generatedFilename, params);
+
+            return await fileResponse(generatedFilename, contentType);
+        } catch (e) {
+            log(e, "error");
+            return new Response("Not Found", { status: 404 });
+        }
+    };
+}

package/src/utils/get-source-filename.d.ts

@@ -1 +1 @@
-export declare function getSourceFilename(source: string, params: Record<string, any>): string;
+export declare function getSourceFilename(source: string, params: Partial<Record<string, string | string[]>>): string;

package/src/utils/get-source-filename.js

@@ -1,21 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSourceFilename = getSourceFilename;
-const path_to_regexp_1 = require("path-to-regexp");
 const log_1 = require("./log");
-const parse_http_source_1 = require("./parse-http-source");
-const repair_params_1 = require("./repair-params");
+/**
+ * `:name`, optionally followed by a path-to-regexp v6 modifier (`+`, `*`, `?`) that is ignored here –
+ * the matched value already contains any slashes. A name must start with a letter, so the port in
+ * `http://localhost:3000/...` is never mistaken for a parameter.
+ */
+const PARAM_PATTERN = /:([A-Za-z_]\w*)[+*?]?/g;
 function getSourceFilename(source, params) {
-    const parsedHttpSource = (0, parse_http_source_1.parseHttpSource)(source);
-    const repairedParams = (0, repair_params_1.repairParams)(params);
-    (0, log_1.log)(repairedParams);
-    if (parsedHttpSource) {
-        // escape port
-        const domain = parsedHttpSource.domain.startsWith(":")
-            ? parsedHttpSource.domain
-            : parsedHttpSource.domain.replace(":", "\\:");
-        const compiled = (0, path_to_regexp_1.compile)(`/${domain}/${parsedHttpSource.path}`, {})(repairedParams);
-        return `${parsedHttpSource.protocol}:/${compiled}`;
-    }
-    return (0, path_to_regexp_1.compile)(source, {})(repairedParams);
+    (0, log_1.log)(params);
+    return source.replace(PARAM_PATTERN, (_match, key) => {
+        const value = params[key];
+        if (value === undefined) {
+            throw new Error(`Missing parameter "${key}" for source "${source}"`);
+        }
+        return Array.isArray(value) ? value.join("/") : value;
+    });
 }

package/src/utils/get-source-filename.test.js

@@ -20,3 +20,24 @@ test("get source filename", () => {
         extension: "jpg",
     })).toStrictEqual("/var/www/path/to/file.jpg");
 });
+test("accepts a string value containing slashes (what URLPattern yields for :filename(.*))", () => {
+    expect((0, get_source_filename_1.getSourceFilename)("https://static.example.dev/:filename+.:extension", {
+        filename: "_next/static/media/logo.941ec59a",
+        extension: "png",
+    })).toStrictEqual("https://static.example.dev/_next/static/media/logo.941ec59a.png");
+});
+test("ignores the * and ? modifiers", () => {
+    expect((0, get_source_filename_1.getSourceFilename)("/var/www/:dir*/:file?.:ext", { dir: "a/b", file: "c", ext: "png" })).toStrictEqual("/var/www/a/b/c.png");
+});
+test("keeps the uploaded-image source intact", () => {
+    expect((0, get_source_filename_1.getSourceFilename)("https://s3.example.dev/:namespace/:p1/:p2/:filename.:extension", {
+        namespace: "product",
+        p1: "0",
+        p2: "f",
+        filename: "0f1e2d3c-1111-2222-3333-444455556666",
+        extension: "jpg",
+    })).toStrictEqual("https://s3.example.dev/product/0/f/0f1e2d3c-1111-2222-3333-444455556666.jpg");
+});
+test("throws when a parameter is missing", () => {
+    expect(() => (0, get_source_filename_1.getSourceFilename)("/var/www/:filename.:extension", { filename: "x" })).toThrow('Missing parameter "extension"');
+});

package/src/utils/get-source-filename.test.ts

@@ -30,3 +30,36 @@ test("get source filename", () => {
         }),
     ).toStrictEqual("/var/www/path/to/file.jpg");
 });
+
+test("accepts a string value containing slashes (what URLPattern yields for :filename(.*))", () => {
+    expect(
+        getSourceFilename("https://static.example.dev/:filename+.:extension", {
+            filename: "_next/static/media/logo.941ec59a",
+            extension: "png",
+        }),
+    ).toStrictEqual("https://static.example.dev/_next/static/media/logo.941ec59a.png");
+});
+
+test("ignores the * and ? modifiers", () => {
+    expect(getSourceFilename("/var/www/:dir*/:file?.:ext", { dir: "a/b", file: "c", ext: "png" })).toStrictEqual(
+        "/var/www/a/b/c.png",
+    );
+});
+
+test("keeps the uploaded-image source intact", () => {
+    expect(
+        getSourceFilename("https://s3.example.dev/:namespace/:p1/:p2/:filename.:extension", {
+            namespace: "product",
+            p1: "0",
+            p2: "f",
+            filename: "0f1e2d3c-1111-2222-3333-444455556666",
+            extension: "jpg",
+        }),
+    ).toStrictEqual("https://s3.example.dev/product/0/f/0f1e2d3c-1111-2222-3333-444455556666.jpg");
+});
+
+test("throws when a parameter is missing", () => {
+    expect(() => getSourceFilename("/var/www/:filename.:extension", { filename: "x" })).toThrow(
+        'Missing parameter "extension"',
+    );
+});

package/src/utils/get-source-filename.ts

@@ -1,21 +1,21 @@
-import { compile } from "path-to-regexp";
 import { log } from "./log";
-import { parseHttpSource } from "./parse-http-source";
-import { repairParams } from "./repair-params";
 
-export function getSourceFilename(source: string, params: Record<string, any>): string {
-    const parsedHttpSource = parseHttpSource(source);
-    const repairedParams = repairParams(params);
-    log(repairedParams);
+/**
+ * `:name`, optionally followed by a path-to-regexp v6 modifier (`+`, `*`, `?`) that is ignored here –
+ * the matched value already contains any slashes. A name must start with a letter, so the port in
+ * `http://localhost:3000/...` is never mistaken for a parameter.
+ */
+const PARAM_PATTERN = /:([A-Za-z_]\w*)[+*?]?/g;
 
-    if (parsedHttpSource) {
-        // escape port
-        const domain = parsedHttpSource.domain.startsWith(":")
-            ? parsedHttpSource.domain
-            : parsedHttpSource.domain.replace(":", "\\:");
-        const compiled = compile(`/${domain}/${parsedHttpSource.path}`, {})(repairedParams);
-        return `${parsedHttpSource.protocol}:/${compiled}`;
-    }
+export function getSourceFilename(source: string, params: Partial<Record<string, string | string[]>>): string {
+    log(params);
 
-    return compile(source, {})(repairedParams);
+    return source.replace(PARAM_PATTERN, (_match, key: string) => {
+        const value = params[key];
+        if (value === undefined) {
+            throw new Error(`Missing parameter "${key}" for source "${source}"`);
+        }
+
+        return Array.isArray(value) ? value.join("/") : value;
+    });
 }

package/src/utils/match-route.d.ts

@@ -0,0 +1,13 @@
+import { Params } from "./tools";
+/**
+ * Express 4 accepted `:name(*)` as "match anything, slashes included". URLPattern rejects a bare `*`
+ * inside a regexp group, so the legacy form is rewritten to the equivalent `(.*)`.
+ */
+export declare function normalizeRoute(route: string): string;
+/**
+ * Compiles a `route` from the resizer config into a matcher. The syntax is the one built into Node's
+ * `URLPattern` (path-to-regexp v6 compatible): `:name`, `:name(regexp)`, `:name+`, several parameters
+ * per segment. Matching is case-insensitive and the captured values are percent-decoded, mirroring the
+ * Express 4 router this replaced.
+ */
+export declare function createRouteMatcher(route: string): (pathname: string) => Params | undefined;

package/src/utils/match-route.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRoute = normalizeRoute;
+exports.createRouteMatcher = createRouteMatcher;
+const log_1 = require("./log");
+const LEGACY_WILDCARD = "(*)";
+/**
+ * Express 4 accepted `:name(*)` as "match anything, slashes included". URLPattern rejects a bare `*`
+ * inside a regexp group, so the legacy form is rewritten to the equivalent `(.*)`.
+ */
+function normalizeRoute(route) {
+    if (!route.includes(LEGACY_WILDCARD)) {
+        return route;
+    }
+    (0, log_1.log)(`Route "${route}" uses the deprecated "(*)" group – use "(.*)" instead.`, "warn");
+    return route.replaceAll(LEGACY_WILDCARD, "(.*)");
+}
+/**
+ * Compiles a `route` from the resizer config into a matcher. The syntax is the one built into Node's
+ * `URLPattern` (path-to-regexp v6 compatible): `:name`, `:name(regexp)`, `:name+`, several parameters
+ * per segment. Matching is case-insensitive and the captured values are percent-decoded, mirroring the
+ * Express 4 router this replaced.
+ */
+function createRouteMatcher(route) {
+    const pattern = new URLPattern({ pathname: normalizeRoute(route) }, { ignoreCase: true });
+    return (pathname) => {
+        var _a;
+        const groups = (_a = pattern.exec({ pathname })) === null || _a === void 0 ? void 0 : _a.pathname.groups;
+        if (groups === undefined) {
+            return undefined;
+        }
+        const params = {};
+        Object.entries(groups).forEach(([key, value]) => {
+            params[key] = value === undefined ? undefined : decodeURIComponent(value);
+        });
+        return params;
+    };
+}

package/src/utils/match-route.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/utils/match-route.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @jest-environment node
+ */
+const match_route_1 = require("./match-route");
+// the two shapes `resizerGetDefaultConfig` (@uxf/core) emits
+const STATIC_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";
+const UPLOAD_ROUTE = "/generated/:namespace/:p1/:p2/:filename([a-f0-9\\-]+)_:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)_:extension.:toFormat";
+test("matches the uploaded-image route produced by resizerImageUrl", () => {
+    const match = (0, match_route_1.createRouteMatcher)(UPLOAD_ROUTE);
+    expect(match("/generated/product/0/f/0f1e2d3c-1111-2222-3333-444455556666_300_x_cv_c_FFF_nt_80_jpg.webp")).toEqual({
+        namespace: "product",
+        p1: "0",
+        p2: "f",
+        filename: "0f1e2d3c-1111-2222-3333-444455556666",
+        width: "300",
+        height: "x",
+        fit: "cv",
+        position: "c",
+        background: "FFF",
+        trim: "nt",
+        quality: "80",
+        extension: "jpg",
+        toFormat: "webp",
+    });
+});
+test("matches the static route with a nested, dotted filename", () => {
+    const match = (0, match_route_1.createRouteMatcher)(STATIC_ROUTE);
+    expect(match("/generated/static/300_200_cv_c_t_nt_x/1/_next/static/media/logo.941ec59a.png.avif")).toEqual({
+        width: "300",
+        height: "200",
+        fit: "cv",
+        position: "c",
+        background: "t",
+        trim: "nt",
+        quality: "x",
+        version: "1",
+        filename: "_next/static/media/logo.941ec59a",
+        extension: "png",
+        toFormat: "avif",
+    });
+});
+test("legacy (*) group matches exactly like (.*)", () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+    const legacy = (0, match_route_1.createRouteMatcher)(STATIC_ROUTE.replace("(.*)", "(*)"));
+    const current = (0, match_route_1.createRouteMatcher)(STATIC_ROUTE);
+    const pathname = "/generated/static/x_x_cn_lt_FFF_nt_75/3/images/deep/dir/file.name.jpg.webp";
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    warnSpy.mockRestore();
+    expect(legacy(pathname)).toEqual(current(pathname));
+    expect(current(pathname)).toMatchObject({
+        filename: "images/deep/dir/file.name",
+        extension: "jpg",
+        toFormat: "webp",
+    });
+});
+test("normalizeRoute rewrites every (*) and leaves other routes alone", () => {
+    expect((0, match_route_1.normalizeRoute)("/a/:x(*)/:y(*)")).toBe("/a/:x(.*)/:y(.*)");
+    expect((0, match_route_1.normalizeRoute)(STATIC_ROUTE)).toBe(STATIC_ROUTE);
+});
+test("matching is case-insensitive (background FFF against [a-z]+)", () => {
+    const match = (0, match_route_1.createRouteMatcher)("/x/:background([a-z]+)");
+    expect(match("/x/FFF")).toEqual({ background: "FFF" });
+    expect(match("/X/fff")).toEqual({ background: "fff" });
+});
+test("percent-decodes captured values", () => {
+    const match = (0, match_route_1.createRouteMatcher)("/files/:filename(.*).:extension");
+    expect(match("/files/My%20Photo.jpg")).toEqual({ filename: "My Photo", extension: "jpg" });
+});
+test("returns undefined when the path does not match", () => {
+    const match = (0, match_route_1.createRouteMatcher)(UPLOAD_ROUTE);
+    expect(match("/generated/static/300_200/x.png.webp")).toBeUndefined();
+    expect(match("/generated/product/0/f/not-a-uuid_300_x_cv_c_FFF_nt_80_jpg.webp")).toBeUndefined();
+    expect(match("/generated/product/0/f/0f1e2d3c_abc_x_cv_c_FFF_nt_80_jpg.webp")).toBeUndefined();
+});
+test("throws on an invalid route at construction time", () => {
+    expect(() => (0, match_route_1.createRouteMatcher)("/x/:a([")).toThrow();
+});

package/src/utils/match-route.test.ts

@@ -0,0 +1,94 @@
+/**
+ * @jest-environment node
+ */
+import { createRouteMatcher, normalizeRoute } from "./match-route";
+
+// the two shapes `resizerGetDefaultConfig` (@uxf/core) emits
+const STATIC_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";
+const UPLOAD_ROUTE =
+    "/generated/:namespace/:p1/:p2/:filename([a-f0-9\\-]+)_:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)_:extension.:toFormat";
+
+test("matches the uploaded-image route produced by resizerImageUrl", () => {
+    const match = createRouteMatcher(UPLOAD_ROUTE);
+
+    expect(match("/generated/product/0/f/0f1e2d3c-1111-2222-3333-444455556666_300_x_cv_c_FFF_nt_80_jpg.webp")).toEqual({
+        namespace: "product",
+        p1: "0",
+        p2: "f",
+        filename: "0f1e2d3c-1111-2222-3333-444455556666",
+        width: "300",
+        height: "x",
+        fit: "cv",
+        position: "c",
+        background: "FFF",
+        trim: "nt",
+        quality: "80",
+        extension: "jpg",
+        toFormat: "webp",
+    });
+});
+
+test("matches the static route with a nested, dotted filename", () => {
+    const match = createRouteMatcher(STATIC_ROUTE);
+
+    expect(match("/generated/static/300_200_cv_c_t_nt_x/1/_next/static/media/logo.941ec59a.png.avif")).toEqual({
+        width: "300",
+        height: "200",
+        fit: "cv",
+        position: "c",
+        background: "t",
+        trim: "nt",
+        quality: "x",
+        version: "1",
+        filename: "_next/static/media/logo.941ec59a",
+        extension: "png",
+        toFormat: "avif",
+    });
+});
+
+test("legacy (*) group matches exactly like (.*)", () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+    const legacy = createRouteMatcher(STATIC_ROUTE.replace("(.*)", "(*)"));
+    const current = createRouteMatcher(STATIC_ROUTE);
+    const pathname = "/generated/static/x_x_cn_lt_FFF_nt_75/3/images/deep/dir/file.name.jpg.webp";
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    warnSpy.mockRestore();
+    expect(legacy(pathname)).toEqual(current(pathname));
+    expect(current(pathname)).toMatchObject({
+        filename: "images/deep/dir/file.name",
+        extension: "jpg",
+        toFormat: "webp",
+    });
+});
+
+test("normalizeRoute rewrites every (*) and leaves other routes alone", () => {
+    expect(normalizeRoute("/a/:x(*)/:y(*)")).toBe("/a/:x(.*)/:y(.*)");
+    expect(normalizeRoute(STATIC_ROUTE)).toBe(STATIC_ROUTE);
+});
+
+test("matching is case-insensitive (background FFF against [a-z]+)", () => {
+    const match = createRouteMatcher("/x/:background([a-z]+)");
+
+    expect(match("/x/FFF")).toEqual({ background: "FFF" });
+    expect(match("/X/fff")).toEqual({ background: "fff" });
+});
+
+test("percent-decodes captured values", () => {
+    const match = createRouteMatcher("/files/:filename(.*).:extension");
+
+    expect(match("/files/My%20Photo.jpg")).toEqual({ filename: "My Photo", extension: "jpg" });
+});
+
+test("returns undefined when the path does not match", () => {
+    const match = createRouteMatcher(UPLOAD_ROUTE);
+
+    expect(match("/generated/static/300_200/x.png.webp")).toBeUndefined();
+    expect(match("/generated/product/0/f/not-a-uuid_300_x_cv_c_FFF_nt_80_jpg.webp")).toBeUndefined();
+    expect(match("/generated/product/0/f/0f1e2d3c_abc_x_cv_c_FFF_nt_80_jpg.webp")).toBeUndefined();
+});
+
+test("throws on an invalid route at construction time", () => {
+    expect(() => createRouteMatcher("/x/:a([")).toThrow();
+});

package/src/utils/match-route.ts

@@ -0,0 +1,41 @@
+import { log } from "./log";
+import { Params } from "./tools";
+
+const LEGACY_WILDCARD = "(*)";
+
+/**
+ * Express 4 accepted `:name(*)` as "match anything, slashes included". URLPattern rejects a bare `*`
+ * inside a regexp group, so the legacy form is rewritten to the equivalent `(.*)`.
+ */
+export function normalizeRoute(route: string): string {
+    if (!route.includes(LEGACY_WILDCARD)) {
+        return route;
+    }
+
+    log(`Route "${route}" uses the deprecated "(*)" group – use "(.*)" instead.`, "warn");
+    return route.replaceAll(LEGACY_WILDCARD, "(.*)");
+}
+
+/**
+ * Compiles a `route` from the resizer config into a matcher. The syntax is the one built into Node's
+ * `URLPattern` (path-to-regexp v6 compatible): `:name`, `:name(regexp)`, `:name+`, several parameters
+ * per segment. Matching is case-insensitive and the captured values are percent-decoded, mirroring the
+ * Express 4 router this replaced.
+ */
+export function createRouteMatcher(route: string): (pathname: string) => Params | undefined {
+    const pattern = new URLPattern({ pathname: normalizeRoute(route) }, { ignoreCase: true });
+
+    return (pathname) => {
+        const groups = pattern.exec({ pathname })?.pathname.groups;
+        if (groups === undefined) {
+            return undefined;
+        }
+
+        const params: Partial<Record<string, string>> = {};
+        Object.entries(groups).forEach(([key, value]) => {
+            params[key] = value === undefined ? undefined : decodeURIComponent(value);
+        });
+
+        return params as unknown as Params;
+    };
+}

package/src/utils/tools.d.ts

@@ -1,24 +1,24 @@
 import type { FitEnum } from "sharp";
 export declare const CONTENT_TYPES: Record<string, string | undefined>;
-export interface Params {
-    width: string;
-    height: string;
-    fit: string;
-    position: string;
-    background: string;
-    trim: string;
-    quality: string;
+export type Params = {
+    width: string | undefined;
+    height: string | undefined;
+    fit: string | undefined;
+    position: string | undefined;
+    background: string | undefined;
+    trim: string | undefined;
+    quality: string | undefined;
     filename: string;
     extension: string;
     toFormat: string;
     p1: string | undefined;
     p2: string | undefined;
     namespace: string | undefined;
-}
+};
 export declare const getQuality: ({ quality }: Params) => number | undefined;
 export declare const getWidth: ({ width }: Params) => number | undefined;
 export declare const getHeight: ({ height }: Params) => number | undefined;
-export declare const getBackground: ({ background }: Params) => string;
+export declare const getBackground: ({ background: bg }: Params) => string;
 export declare const getFit: ({ fit }: Params) => keyof FitEnum;
 export declare const getPosition: ({ position }: Params) => string | number | undefined;
 export declare const getWithoutEnlargement: ({ extension }: Params) => boolean;

package/src/utils/tools.js

@@ -33,7 +33,7 @@ const getWidth = ({ width }) => (width && width !== "x" ? Number(width) : undefi
 exports.getWidth = getWidth;
 const getHeight = ({ height }) => (height && height !== "x" ? Number(height) : undefined);
 exports.getHeight = getHeight;
-const getBackground = ({ background }) => (background === "t" ? "transparent" : `#${background}`);
+const getBackground = ({ background: bg }) => bg === undefined || bg === "t" ? "transparent" : `#${bg}`;
 exports.getBackground = getBackground;
 const getFit = ({ fit }) => { var _a; return (fit ? ((_a = FIT_OPTIONS[fit]) !== null && _a !== void 0 ? _a : "cover") : "cover"); };
 exports.getFit = getFit;
@@ -41,5 +41,5 @@ const getPosition = ({ position }) => { var _a; return (position ? ((_a = POSITI
 exports.getPosition = getPosition;
 const getWithoutEnlargement = ({ extension }) => extension !== "svg";
 exports.getWithoutEnlargement = getWithoutEnlargement;
-const getTrim = ({ trim }) => (trim === "nt" ? undefined : Number(trim));
+const getTrim = ({ trim }) => (trim === undefined || trim === "nt" ? undefined : Number(trim));
 exports.getTrim = getTrim;

package/src/utils/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/utils/tools.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tools_1 = require("./tools");
+const minimal = {
+    width: "146",
+    height: "100",
+    fit: undefined,
+    position: undefined,
+    background: undefined,
+    trim: undefined,
+    quality: undefined,
+    filename: "logo",
+    extension: "png",
+    toFormat: "avif",
+    p1: undefined,
+    p2: undefined,
+    namespace: undefined,
+};
+test("a route without the optional parameters falls back to defaults", () => {
+    expect((0, tools_1.getWidth)(minimal)).toBe(146);
+    expect((0, tools_1.getHeight)(minimal)).toBe(100);
+    expect((0, tools_1.getFit)(minimal)).toBe("cover");
+    expect((0, tools_1.getPosition)(minimal)).toBeUndefined();
+    expect((0, tools_1.getBackground)(minimal)).toBe("transparent");
+    expect((0, tools_1.getTrim)(minimal)).toBeUndefined();
+    expect((0, tools_1.getQuality)(minimal)).toBeUndefined();
+});
+test("explicit parameters are mapped", () => {
+    const params = {
+        ...minimal,
+        width: "x",
+        fit: "cn",
+        position: "lt",
+        background: "t",
+        trim: "10",
+        quality: "75",
+    };
+    expect((0, tools_1.getWidth)(params)).toBeUndefined();
+    expect((0, tools_1.getFit)(params)).toBe("contain");
+    expect((0, tools_1.getPosition)(params)).toBe("left top");
+    expect((0, tools_1.getBackground)(params)).toBe("transparent");
+    expect((0, tools_1.getTrim)(params)).toBe(10);
+    expect((0, tools_1.getQuality)(params)).toBe(75);
+    expect((0, tools_1.getBackground)({ ...minimal, background: "ff0000" })).toBe("#ff0000");
+    expect((0, tools_1.getTrim)({ ...minimal, trim: "nt" })).toBeUndefined();
+});