@hazeljs/i18n 0.2.0-beta.57

package/dist/i18n.interceptor.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nInterceptor = void 0;
+const i18n_middleware_1 = require("./i18n.middleware");
+/**
+ * Optional interceptor that automatically translates a `message` field found
+ * in the response object.
+ *
+ * The `message` value is treated as an i18n key.  If the key exists in the
+ * translation store for the request locale, it is replaced in-place; otherwise
+ * the original value is preserved.
+ *
+ * Register it per-controller with @UseInterceptors(I18nInterceptor) or
+ * globally via the HazelApp interceptor API.
+ *
+ * @example
+ * // Returning from a controller:
+ * return { message: 'user.created', data: user };
+ * // → { message: 'User created successfully.', data: user }  (if key exists)
+ */
+class I18nInterceptor {
+    constructor(i18n) {
+        this.i18n = i18n;
+    }
+    async intercept(context, next) {
+        const result = await next();
+        if (!result || typeof result !== 'object' || Array.isArray(result)) {
+            return result;
+        }
+        const body = result;
+        if (typeof body.message !== 'string') {
+            return result;
+        }
+        const locale = this.extractLocale(context);
+        const translated = this.i18n.t(body.message, { locale });
+        // Only substitute when a real translation was found (key !== translated).
+        if (translated !== body.message) {
+            return { ...body, message: translated };
+        }
+        return result;
+    }
+    /**
+     * Reads the locale attached by LocaleMiddleware from the raw request object.
+     */
+    extractLocale(context) {
+        const req = context.req ?? context['request'];
+        if (!req || typeof req !== 'object')
+            return undefined;
+        return req[i18n_middleware_1.LOCALE_KEY];
+    }
+}
+exports.I18nInterceptor = I18nInterceptor;

package/dist/i18n.interceptor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=i18n.interceptor.test.d.ts.map

package/dist/i18n.interceptor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.interceptor.test.d.ts","sourceRoot":"","sources":["../src/i18n.interceptor.test.ts"],"names":[],"mappings":""}

package/dist/i18n.interceptor.test.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    Service: () => () => undefined,
+}));
+const i18n_interceptor_1 = require("./i18n.interceptor");
+const i18n_service_1 = require("./i18n.service");
+const i18n_middleware_1 = require("./i18n.middleware");
+const DEFAULT_OPTIONS = {
+    defaultLocale: 'en',
+    fallbackLocale: 'en',
+    translationsPath: './translations',
+    detection: ['query', 'cookie', 'header'],
+    queryParam: 'lang',
+    cookieName: 'locale',
+    isGlobal: true,
+};
+function makeService(store = new Map(), opts = DEFAULT_OPTIONS) {
+    const svc = new i18n_service_1.I18nService();
+    svc.initialize(store, opts);
+    return svc;
+}
+function makeStore(entries) {
+    const store = new Map();
+    for (const [locale, map] of Object.entries(entries)) {
+        store.set(locale, map);
+    }
+    return store;
+}
+function makeContext(locale) {
+    const req = {};
+    if (locale)
+        req[i18n_middleware_1.LOCALE_KEY] = locale;
+    return { req };
+}
+describe('I18nInterceptor', () => {
+    describe('intercept()', () => {
+        it('passes through null result', async () => {
+            const svc = makeService();
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const next = jest.fn().mockResolvedValue(null);
+            const result = await interceptor.intercept(makeContext(), next);
+            expect(result).toBeNull();
+        });
+        it('passes through non-object result (string)', async () => {
+            const svc = makeService();
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const next = jest.fn().mockResolvedValue('plain string');
+            const result = await interceptor.intercept(makeContext(), next);
+            expect(result).toBe('plain string');
+        });
+        it('passes through array result', async () => {
+            const svc = makeService();
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const next = jest.fn().mockResolvedValue([1, 2, 3]);
+            const result = await interceptor.intercept(makeContext(), next);
+            expect(result).toEqual([1, 2, 3]);
+        });
+        it('passes through object without message field', async () => {
+            const svc = makeService();
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const body = { data: { id: 1 } };
+            const next = jest.fn().mockResolvedValue(body);
+            const result = await interceptor.intercept(makeContext(), next);
+            expect(result).toBe(body);
+        });
+        it('passes through when message is not a string', async () => {
+            const svc = makeService();
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const body = { message: 42 };
+            const next = jest.fn().mockResolvedValue(body);
+            const result = await interceptor.intercept(makeContext(), next);
+            expect(result).toBe(body);
+        });
+        it('translates the message field when a key is found', async () => {
+            const store = makeStore({ en: { user: { created: 'User created successfully.' } } });
+            const svc = makeService(store);
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const body = { message: 'user.created', data: { id: 1 } };
+            const next = jest.fn().mockResolvedValue(body);
+            const result = await interceptor.intercept(makeContext('en'), next);
+            expect(result).toEqual({ message: 'User created successfully.', data: { id: 1 } });
+        });
+        it('preserves the original message when the key is not found', async () => {
+            const svc = makeService(new Map());
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const body = { message: 'unknown.key' };
+            const next = jest.fn().mockResolvedValue(body);
+            const result = await interceptor.intercept(makeContext('en'), next);
+            expect(result).toBe(body);
+        });
+        it('uses locale from request context', async () => {
+            const store = makeStore({
+                en: { greeting: 'Hello' },
+                fr: { greeting: 'Bonjour' },
+            });
+            const svc = makeService(store, { ...DEFAULT_OPTIONS, defaultLocale: 'en' });
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const body = { message: 'greeting' };
+            const next = jest.fn().mockResolvedValue(body);
+            const result = await interceptor.intercept(makeContext('fr'), next);
+            expect(result.message).toBe('Bonjour');
+        });
+        it('handles context without req (no locale)', async () => {
+            const store = makeStore({ en: { hi: 'Hi there' } });
+            const svc = makeService(store);
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const body = { message: 'hi' };
+            const next = jest.fn().mockResolvedValue(body);
+            // context with no req
+            const result = await interceptor.intercept({}, next);
+            expect(result.message).toBe('Hi there');
+        });
+        it('handles context with "request" key instead of "req"', async () => {
+            const store = makeStore({ en: { bye: 'Goodbye' } });
+            const svc = makeService(store);
+            const interceptor = new i18n_interceptor_1.I18nInterceptor(svc);
+            const body = { message: 'bye' };
+            const next = jest.fn().mockResolvedValue(body);
+            const ctx = { request: { [i18n_middleware_1.LOCALE_KEY]: 'en' } };
+            const result = await interceptor.intercept(ctx, next);
+            expect(result.message).toBe('Goodbye');
+        });
+    });
+});

package/dist/i18n.middleware.d.ts

@@ -0,0 +1,55 @@
+import { Request, Response } from '@hazeljs/core';
+import { ResolvedI18nOptions } from './types';
+/**
+ * Symbol used to attach the detected locale to the request object so that
+ * downstream handlers and the @Lang() decorator can read it.
+ */
+export declare const LOCALE_KEY = "__hazel_locale__";
+/**
+ * Middleware that detects the request locale and stores it on the request
+ * object.  Detection is attempted in the order specified by
+ * I18nOptions.detection (default: query → cookie → header).
+ *
+ * Usage — register on the HazelApp before route handling:
+ *
+ * ```ts
+ * const localeMiddleware = new LocaleMiddleware(options);
+ * app.use((req, res, next) => localeMiddleware.handle(req, res, next));
+ * ```
+ */
+export declare class LocaleMiddleware {
+    private readonly options;
+    constructor(options: ResolvedI18nOptions);
+    handle(req: Request, res: Response, next: () => void): void;
+    /**
+     * Run through each configured strategy in priority order and return the
+     * first valid locale found, or the default locale as a fallback.
+     */
+    private detect;
+    /**
+     * Parse the Cookie header and extract the value for the given name.
+     */
+    private parseCookie;
+    /**
+     * Parse the Accept-Language header and return the highest-priority locale
+     * that looks like a valid BCP-47 tag.
+     *
+     * Example: "fr-FR,fr;q=0.9,en;q=0.8" → "fr-FR"
+     */
+    private parseAcceptLanguage;
+    /**
+     * A locale is "valid" if it looks like a non-empty BCP-47 tag
+     * (letters, digits, hyphens, underscores).
+     */
+    private isValid;
+    /**
+     * Factory method for use with HazelApp.use() or route-level middleware.
+     */
+    static create(options: ResolvedI18nOptions): (req: Request, res: Response, next: () => void) => void;
+}
+/**
+ * Reads the locale that was attached to the request by LocaleMiddleware.
+ * Returns undefined if the middleware was not applied.
+ */
+export declare function getLocaleFromRequest(req: Request): string | undefined;
+//# sourceMappingURL=i18n.middleware.d.ts.map

package/dist/i18n.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.middleware.d.ts","sourceRoot":"","sources":["../src/i18n.middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,mBAAmB;IAEzD,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAQ3D;;;OAGG;IACH,OAAO,CAAC,MAAM;IAwBd;;OAEG;IACH,OAAO,CAAC,WAAW;IAcnB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;OAGG;IACH,OAAO,CAAC,OAAO;IAIf;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,mBAAmB,GAC3B,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI;CAI3D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAErE"}

package/dist/i18n.middleware.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleMiddleware = exports.LOCALE_KEY = void 0;
+exports.getLocaleFromRequest = getLocaleFromRequest;
+/**
+ * Symbol used to attach the detected locale to the request object so that
+ * downstream handlers and the @Lang() decorator can read it.
+ */
+exports.LOCALE_KEY = '__hazel_locale__';
+/**
+ * Middleware that detects the request locale and stores it on the request
+ * object.  Detection is attempted in the order specified by
+ * I18nOptions.detection (default: query → cookie → header).
+ *
+ * Usage — register on the HazelApp before route handling:
+ *
+ * ```ts
+ * const localeMiddleware = new LocaleMiddleware(options);
+ * app.use((req, res, next) => localeMiddleware.handle(req, res, next));
+ * ```
+ */
+class LocaleMiddleware {
+    constructor(options) {
+        this.options = options;
+    }
+    handle(req, res, next) {
+        const locale = this.detect(req);
+        req[exports.LOCALE_KEY] = locale;
+        // Expose the detected locale as a response header so clients can confirm.
+        res.setHeader('Content-Language', locale);
+        next();
+    }
+    /**
+     * Run through each configured strategy in priority order and return the
+     * first valid locale found, or the default locale as a fallback.
+     */
+    detect(req) {
+        for (const strategy of this.options.detection) {
+            switch (strategy) {
+                case 'query': {
+                    const lang = req.query?.[this.options.queryParam];
+                    if (lang && this.isValid(lang))
+                        return lang;
+                    break;
+                }
+                case 'cookie': {
+                    const cookieLocale = this.parseCookie(req, this.options.cookieName);
+                    if (cookieLocale && this.isValid(cookieLocale))
+                        return cookieLocale;
+                    break;
+                }
+                case 'header': {
+                    const headerLocale = this.parseAcceptLanguage(req);
+                    if (headerLocale && this.isValid(headerLocale))
+                        return headerLocale;
+                    break;
+                }
+            }
+        }
+        return this.options.defaultLocale;
+    }
+    /**
+     * Parse the Cookie header and extract the value for the given name.
+     */
+    parseCookie(req, name) {
+        const cookieHeader = req.headers?.['cookie'] ?? req.headers?.['Cookie'];
+        if (!cookieHeader)
+            return undefined;
+        for (const pair of cookieHeader.split(';')) {
+            const [key, ...rest] = pair.trim().split('=');
+            if (key?.trim() === name) {
+                return decodeURIComponent(rest.join('=').trim());
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Parse the Accept-Language header and return the highest-priority locale
+     * that looks like a valid BCP-47 tag.
+     *
+     * Example: "fr-FR,fr;q=0.9,en;q=0.8" → "fr-FR"
+     */
+    parseAcceptLanguage(req) {
+        const header = req.headers?.['accept-language'] ?? req.headers?.['Accept-Language'];
+        if (!header)
+            return undefined;
+        // Parse and sort by q-value, then return the first locale code.
+        const locales = header
+            .split(',')
+            .map((entry) => {
+            const [locale, q] = entry.trim().split(';q=');
+            return { locale: locale.trim(), q: q ? parseFloat(q) : 1.0 };
+        })
+            .sort((a, b) => b.q - a.q)
+            .map((entry) => entry.locale);
+        return locales[0];
+    }
+    /**
+     * A locale is "valid" if it looks like a non-empty BCP-47 tag
+     * (letters, digits, hyphens, underscores).
+     */
+    isValid(locale) {
+        return /^[a-zA-Z]{2,8}([-_][a-zA-Z0-9]{2,8})*$/.test(locale);
+    }
+    /**
+     * Factory method for use with HazelApp.use() or route-level middleware.
+     */
+    static create(options) {
+        const mw = new LocaleMiddleware(options);
+        return (req, res, next) => mw.handle(req, res, next);
+    }
+}
+exports.LocaleMiddleware = LocaleMiddleware;
+/**
+ * Reads the locale that was attached to the request by LocaleMiddleware.
+ * Returns undefined if the middleware was not applied.
+ */
+function getLocaleFromRequest(req) {
+    return req[exports.LOCALE_KEY];
+}

package/dist/i18n.middleware.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=i18n.middleware.test.d.ts.map

package/dist/i18n.middleware.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.middleware.test.d.ts","sourceRoot":"","sources":["../src/i18n.middleware.test.ts"],"names":[],"mappings":""}

package/dist/i18n.middleware.test.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+}));
+const i18n_middleware_1 = require("./i18n.middleware");
+const DEFAULT_OPTIONS = {
+    defaultLocale: 'en',
+    fallbackLocale: 'en',
+    translationsPath: './translations',
+    detection: ['query', 'cookie', 'header'],
+    queryParam: 'lang',
+    cookieName: 'locale',
+    isGlobal: true,
+};
+function makeReq(overrides = {}) {
+    return {
+        query: {},
+        headers: {},
+        ...overrides,
+    };
+}
+function makeRes() {
+    return { setHeader: jest.fn() };
+}
+describe('LocaleMiddleware', () => {
+    let middleware;
+    let next;
+    beforeEach(() => {
+        middleware = new i18n_middleware_1.LocaleMiddleware(DEFAULT_OPTIONS);
+        next = jest.fn();
+    });
+    describe('handle()', () => {
+        it('calls next()', () => {
+            const req = makeReq();
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(next).toHaveBeenCalled();
+        });
+        it('sets the locale on the request object', () => {
+            const req = makeReq({ query: { lang: 'fr' } });
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('fr');
+        });
+        it('sets Content-Language response header', () => {
+            const req = makeReq({ query: { lang: 'de' } });
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(res.setHeader).toHaveBeenCalledWith('Content-Language', 'de');
+        });
+        it('falls back to defaultLocale when no strategy matches', () => {
+            const req = makeReq();
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('en');
+        });
+    });
+    describe('query strategy', () => {
+        it('picks locale from query parameter', () => {
+            const req = makeReq({ query: { lang: 'fr' } });
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('fr');
+        });
+        it('ignores invalid locale in query', () => {
+            const req = makeReq({ query: { lang: '!invalid!' } });
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('en');
+        });
+        it('uses custom queryParam name', () => {
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, queryParam: 'locale' });
+            const req = makeReq({ query: { locale: 'ja' } });
+            const res = makeRes();
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('ja');
+        });
+    });
+    describe('cookie strategy', () => {
+        it('picks locale from cookie header', () => {
+            const req = makeReq({ headers: { cookie: 'locale=fr; theme=dark' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['cookie'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('fr');
+        });
+        it('picks locale from Cookie (capitalized) header', () => {
+            const req = makeReq({ headers: { Cookie: 'locale=de' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['cookie'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('de');
+        });
+        it('falls back to default when cookie is absent', () => {
+            const req = makeReq({ headers: {} });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['cookie'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('en');
+        });
+        it('falls back when cookie name does not match', () => {
+            const req = makeReq({ headers: { cookie: 'othercookie=fr' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['cookie'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('en');
+        });
+        it('handles cookie values with = in the value', () => {
+            const req = makeReq({ headers: { cookie: 'locale=zh-TW; token=abc=def' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['cookie'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('zh-TW');
+        });
+        it('handles URL-encoded cookie values', () => {
+            const req = makeReq({ headers: { cookie: 'locale=zh-TW' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['cookie'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('zh-TW');
+        });
+        it('uses custom cookieName', () => {
+            const req = makeReq({ headers: { cookie: 'lang_pref=ja' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({
+                ...DEFAULT_OPTIONS,
+                cookieName: 'lang_pref',
+                detection: ['cookie'],
+            });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('ja');
+        });
+    });
+    describe('header strategy', () => {
+        it('picks locale from Accept-Language header', () => {
+            const req = makeReq({ headers: { 'accept-language': 'fr-FR,fr;q=0.9,en;q=0.8' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['header'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('fr-FR');
+        });
+        it('picks locale from Accept-Language (capitalized) header', () => {
+            const req = makeReq({ headers: { 'Accept-Language': 'de' } });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['header'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('de');
+        });
+        it('sorts by q-value and picks highest priority locale', () => {
+            const req = makeReq({
+                headers: { 'accept-language': 'en;q=0.5,ja;q=0.9,fr;q=0.7' },
+            });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['header'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('ja');
+        });
+        it('falls back to default when no Accept-Language header', () => {
+            const req = makeReq({ headers: {} });
+            const res = makeRes();
+            const mw = new i18n_middleware_1.LocaleMiddleware({ ...DEFAULT_OPTIONS, detection: ['header'] });
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('en');
+        });
+    });
+    describe('detection priority', () => {
+        it('prefers query over cookie and header', () => {
+            const req = makeReq({
+                query: { lang: 'fr' },
+                headers: {
+                    cookie: 'locale=de',
+                    'accept-language': 'ja',
+                },
+            });
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('fr');
+        });
+        it('falls through to cookie when query has no valid locale', () => {
+            const req = makeReq({
+                query: {},
+                headers: {
+                    cookie: 'locale=de',
+                    'accept-language': 'ja',
+                },
+            });
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('de');
+        });
+        it('falls through to header when query and cookie have no valid locale', () => {
+            const req = makeReq({
+                query: {},
+                headers: {
+                    'accept-language': 'ja',
+                },
+            });
+            const res = makeRes();
+            middleware.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('ja');
+        });
+        it('respects custom detection order [header, query]', () => {
+            const mw = new i18n_middleware_1.LocaleMiddleware({
+                ...DEFAULT_OPTIONS,
+                detection: ['header', 'query'],
+            });
+            const req = makeReq({
+                query: { lang: 'fr' },
+                headers: { 'accept-language': 'de' },
+            });
+            const res = makeRes();
+            mw.handle(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('de');
+        });
+    });
+    describe('LocaleMiddleware.create()', () => {
+        it('returns a middleware function', () => {
+            const fn = i18n_middleware_1.LocaleMiddleware.create(DEFAULT_OPTIONS);
+            expect(typeof fn).toBe('function');
+        });
+        it('created function applies locale detection', () => {
+            const fn = i18n_middleware_1.LocaleMiddleware.create(DEFAULT_OPTIONS);
+            const req = makeReq({ query: { lang: 'fr' } });
+            const res = makeRes();
+            fn(req, res, next);
+            expect(req[i18n_middleware_1.LOCALE_KEY]).toBe('fr');
+        });
+    });
+});
+describe('getLocaleFromRequest()', () => {
+    it('returns the locale set on the request', () => {
+        const req = { [i18n_middleware_1.LOCALE_KEY]: 'fr' };
+        expect((0, i18n_middleware_1.getLocaleFromRequest)(req)).toBe('fr');
+    });
+    it('returns undefined when locale is not set', () => {
+        expect((0, i18n_middleware_1.getLocaleFromRequest)({})).toBeUndefined();
+    });
+});