cloudflare-next-intl 0.2.0 → 0.2.2

package/dist/src/config/middleware.d.ts

@@ -9,10 +9,10 @@ export declare const localesSet: Set<string>;
  * @param request The incoming request (pass through from your `middleware.ts`).
  * @param options.middlewareHandler  Your own logic (auth, feature flags, etc.),
  *   run alongside locale routing — see {@link MiddlewareCustomHandler} for the
- *   full contract (when it runs, what `targetUrl` means, what to return).
- * @param options.runHandlerOnRedirect  By default, `middlewareHandler` only
- *   runs when the library is NOT performing a locale redirect (i.e. on
- *   rewrite or `next()`). Set to `true` to also run it on redirects.
+ *   full contract (`rewriteUrl` / `redirectUrl` and what to return).
+ * @param options.runHandlerOnRedirect  By default, `middlewareHandler` does
+ *   NOT run for the locale-redirect case (so it never receives a
+ *   `redirectUrl`). Set to `true` to also run it on redirects.
  *   Defaults to `false`.
  */
 export default function intlMiddleware(request: NextRequest, options?: {

package/dist/src/config/middleware.js

@@ -26,10 +26,10 @@ export const localesSet = new Set(config.locales);
  * @param request The incoming request (pass through from your `middleware.ts`).
  * @param options.middlewareHandler  Your own logic (auth, feature flags, etc.),
  *   run alongside locale routing — see {@link MiddlewareCustomHandler} for the
- *   full contract (when it runs, what `targetUrl` means, what to return).
- * @param options.runHandlerOnRedirect  By default, `middlewareHandler` only
- *   runs when the library is NOT performing a locale redirect (i.e. on
- *   rewrite or `next()`). Set to `true` to also run it on redirects.
+ *   full contract (`rewriteUrl` / `redirectUrl` and what to return).
+ * @param options.runHandlerOnRedirect  By default, `middlewareHandler` does
+ *   NOT run for the locale-redirect case (so it never receives a
+ *   `redirectUrl`). Set to `true` to also run it on redirects.
  *   Defaults to `false`.
  */
 export default async function intlMiddleware(request, options) {
@@ -67,16 +67,19 @@ export default async function intlMiddleware(request, options) {
         const effectiveLocaleForRequest = urlLocale ?? initialChosenLocale;
         let response;
         let isRedirect = false;
-        let targetUrl;
+        let rewriteUrl;
+        let redirectUrl;
         if (!urlLocale) {
             const targetPath = `/${effectiveLocaleForRequest}${pathWithoutLocale === '/' ? '' : pathWithoutLocale}`;
-            targetUrl = new URL(`${targetPath}${search}${hash}`, request.url);
+            const localeUrl = new URL(`${targetPath}${search}${hash}`, request.url);
             if (initialChosenLocale === config.defaultLocale) {
-                response = NextResponse.rewrite(targetUrl, { request });
+                rewriteUrl = localeUrl;
+                response = NextResponse.rewrite(localeUrl, { request });
             }
             else {
                 isRedirect = true;
-                response = NextResponse.redirect(targetUrl, request);
+                redirectUrl = localeUrl;
+                response = NextResponse.redirect(localeUrl, request);
             }
         }
         else {
@@ -85,7 +88,7 @@ export default async function intlMiddleware(request, options) {
             });
         }
         if (options?.middlewareHandler && (!isRedirect || options.runHandlerOnRedirect)) {
-            const customResponse = await options.middlewareHandler(request, effectiveLocaleForRequest, targetUrl);
+            const customResponse = await options.middlewareHandler(effectiveLocaleForRequest, rewriteUrl, redirectUrl);
             if (customResponse) {
                 response = customResponse;
             }

package/dist/src/server/functions/server.js

@@ -4,6 +4,7 @@ import { localeCookieName } from "../../config/cookie_key";
 import { getLocaleCache, getMessageCache, setLocaleCache, setMessageForLocaleCache } from "../../general/cache_variables";
 import { cache } from "react";
 import { localesSet } from "../../config/middleware";
+const isDev = process.env.NODE_ENV === 'development';
 /**
  * Loads and caches messages for a specific locale using dynamic import.
  * Prevents redundant file loads and handles import errors gracefully.
@@ -11,7 +12,10 @@ import { localesSet } from "../../config/middleware";
  * @returns A promise that resolves to the TranslationObject for the given locale.
  */
 async function iGetMessage(locale) {
-    const message = getMessageCache(locale);
+    // In dev, always re-import so editing a messages/*.json file takes effect
+    // on the next request without a full server restart. loadedTranslations
+    // is a module-level cache that otherwise persists for the whole process.
+    const message = isDev ? undefined : getMessageCache(locale);
     if (message) {
         return message;
     }

package/dist/src/types/types.d.ts

@@ -1,4 +1,4 @@
-import type { NextRequest, NextResponse } from 'next/server';
+import type { NextResponse } from 'next/server';
 import type { Languages } from 'next/dist/lib/metadata/types/alternative-urls-types';
 import type { Videos } from 'next/dist/lib/metadata/types/metadata-types';
 /**
@@ -6,44 +6,37 @@ import type { Videos } from 'next/dist/lib/metadata/types/metadata-types';
  * (e.g. auth, feature flags, A/B tests) — on top of the library's own
  * locale routing (locale-prefix rewrite/redirect).
  *
- * Called AFTER the library has resolved the locale for this request, but
- * BEFORE it builds its own `NextResponse`:
- * - When `targetUrl` is `undefined`: the request already had a valid
- *   locale prefix (e.g. `/en/about`) — the library would otherwise call
- *   `NextResponse.next()`.
- * - When `targetUrl` is set: the library resolved a locale-prefixed URL
- *   the request should be routed to (e.g. `/` -> `/en/`). By default the
- *   library still performs this rewrite/redirect itself — `targetUrl` is
- *   informational, so you can react to it (e.g. log it, add a header),
- *   NOT something you are required to apply yourself.
- *   - If `initialChosenLocale === defaultLocale`, the library rewrites to
- *     `targetUrl` (URL bar unchanged).
- *   - Otherwise, the library redirects to `targetUrl` (only when
- *     `runHandlerOnRedirect: true` is also passed — by default this
- *     handler does NOT run on redirects).
+ * STRICT RULE — at most ONE of `rewriteUrl` / `redirectUrl` is ever set, and
+ * whichever is set tells you exactly what to do:
+ * - `rewriteUrl` set: apply `NextResponse.rewrite(rewriteUrl, { request })`
+ *   (locale matches the default locale — URL bar stays unchanged).
+ * - `redirectUrl` set: apply `NextResponse.redirect(redirectUrl, request)`
+ *   (locale differs from the URL — visible redirect). The handler only runs
+ *   for this case when `runHandlerOnRedirect: true` is passed.
+ * - BOTH undefined: no locale routing needed (URL already has the right
+ *   locale prefix). This is where your own logic belongs — return
+ *   `NextResponse.next({ request })`, or your own redirect (e.g. auth).
  *
- * @param request   The incoming request.
- * @param locale    The resolved locale for this request (e.g. `"en"`).
- * @param targetUrl The locale-prefixed URL the library will rewrite/redirect
- *                  to, or `undefined` when no rewrite/redirect is needed.
- * @returns          - A `NextResponse` to fully REPLACE the library's default
- *                      response (e.g. `NextResponse.redirect(...)` to send an
- *                      unauthenticated user to `/login` instead).
- *                    - `null` to keep the library's default response
- *                      (rewrite/redirect/`next()`) as-is — this is the common case.
+ * Returning `null` in any case makes the library apply its own default,
+ * which is the same rewrite/redirect/`next()` described above.
+ *
+ * @param locale      The resolved locale for this request (e.g. `"en"`).
+ * @param rewriteUrl  URL to rewrite to, or `undefined`.
+ * @param redirectUrl URL to redirect to, or `undefined`.
+ * @returns           A `NextResponse` to use for this request, or `null` to
+ *                    let the library build the default one.
  *
  * @example
  * ```ts
- * middlewareHandler: (request, locale, targetUrl) => {
- *   const session = request.cookies.get("session")?.value;
- *   if (!session) {
- *     return NextResponse.redirect(new URL(`/${locale}/login`, request.url));
- *   }
- *   return null; // keep default locale routing
+ * middlewareHandler: (locale, rewriteUrl, redirectUrl) => {
+ *   if (rewriteUrl) return NextResponse.rewrite(rewriteUrl, { request });
+ *   if (redirectUrl) return NextResponse.redirect(redirectUrl, request);
+ *   // No locale routing needed — your own logic goes here.
+ *   return NextResponse.next({ request });
  * }
  * ```
  */
-export type MiddlewareCustomHandler = (request: NextRequest, locale: string, targetUrl: URL | undefined) => NextResponse<unknown> | null | Promise<NextResponse<unknown> | null>;
+export type MiddlewareCustomHandler = (locale: string, rewriteUrl: URL | undefined, redirectUrl: URL | undefined) => NextResponse<unknown> | null | Promise<NextResponse<unknown> | null>;
 /** Your app's list of supported locale codes, e.g. `["en", "de"] as const`. */
 export type Locales = readonly string[];
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",