@uxf/resizer 11.126.0 → 11.129.0

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();
+});

package/src/utils/tools.test.ts

@@ -0,0 +1,48 @@
+import { getBackground, getFit, getHeight, getPosition, getQuality, getTrim, getWidth, Params } from "./tools";
+
+const minimal: Params = {
+    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(getWidth(minimal)).toBe(146);
+    expect(getHeight(minimal)).toBe(100);
+    expect(getFit(minimal)).toBe("cover");
+    expect(getPosition(minimal)).toBeUndefined();
+    expect(getBackground(minimal)).toBe("transparent");
+    expect(getTrim(minimal)).toBeUndefined();
+    expect(getQuality(minimal)).toBeUndefined();
+});
+
+test("explicit parameters are mapped", () => {
+    const params: Params = {
+        ...minimal,
+        width: "x",
+        fit: "cn",
+        position: "lt",
+        background: "t",
+        trim: "10",
+        quality: "75",
+    };
+
+    expect(getWidth(params)).toBeUndefined();
+    expect(getFit(params)).toBe("contain");
+    expect(getPosition(params)).toBe("left top");
+    expect(getBackground(params)).toBe("transparent");
+    expect(getTrim(params)).toBe(10);
+    expect(getQuality(params)).toBe(75);
+    expect(getBackground({ ...minimal, background: "ff0000" })).toBe("#ff0000");
+    expect(getTrim({ ...minimal, trim: "nt" })).toBeUndefined();
+});

package/src/utils/tools.ts

@@ -29,14 +29,14 @@ export const CONTENT_TYPES: Record<string, string | undefined> = {
     jpeg: "image/jpeg",
 };
 
-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;
@@ -44,13 +44,14 @@ export interface Params {
     p1: string | undefined;
     p2: string | undefined;
     namespace: string | undefined;
-}
+};
 
 export const getQuality = ({ quality }: Params) => (quality && quality !== "x" ? Number(quality) : undefined);
 export const getWidth = ({ width }: Params) => (width && width !== "x" ? Number(width) : undefined);
 export const getHeight = ({ height }: Params) => (height && height !== "x" ? Number(height) : undefined);
-export const getBackground = ({ background }: Params) => (background === "t" ? "transparent" : `#${background}`);
+export const getBackground = ({ background: bg }: Params) =>
+    bg === undefined || bg === "t" ? "transparent" : `#${bg}`;
 export const getFit = ({ fit }: Params): keyof FitEnum => (fit ? (FIT_OPTIONS[fit] ?? "cover") : "cover");
 export const getPosition = ({ position }: Params) => (position ? (POSITION_OPTIONS[position] ?? "centre") : undefined);
 export const getWithoutEnlargement = ({ extension }: Params) => extension !== "svg";
-export const getTrim = ({ trim }: Params) => (trim === "nt" ? undefined : Number(trim));
+export const getTrim = ({ trim }: Params) => (trim === undefined || trim === "nt" ? undefined : Number(trim));

package/src/middleware.d.ts

@@ -1,5 +0,0 @@
-export type Config = Array<{
-    route: string;
-    source: string;
-}>;
-export declare const resizerMiddleware: (config: Config) => import("express-serve-static-core").Router;