@inlang/paraglide-js 2.0.11 → 2.0.13

package/dist/compiler/runtime/set-locale.test.js

@@ -10,16 +10,14 @@ test("sets the cookie to a different locale", async () => {
     globalThis.window.location = { hostname: "example.com" };
     globalThis.window.location.reload = vi.fn();
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie"],
-            cookieName: "PARAGLIDE_LOCALE",
-        },
+        strategy: ["cookie"],
+        cookieName: "PARAGLIDE_LOCALE",
     });
     globalThis.document.cookie = "PARAGLIDE_LOCALE=en";
     runtime.setLocale("de");
@@ -37,17 +35,15 @@ test("sets the cookie with explicit domain to a different locale navigating subd
     globalThis.window.location = { hostname: "web.example.com" };
     globalThis.window.location.reload = vi.fn();
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie"],
-            cookieName: "PARAGLIDE_LOCALE",
-            cookieDomain: "example.com",
-        },
+        strategy: ["cookie"],
+        cookieName: "PARAGLIDE_LOCALE",
+        cookieDomain: "example.com",
     });
     globalThis.document.cookie = "PARAGLIDE_LOCALE=en";
     runtime.setLocale("de");
@@ -65,17 +61,15 @@ test("sets the cookie with explicit domain to a different locale navigating doma
     globalThis.window.location = { hostname: "example.com" };
     globalThis.window.location.reload = vi.fn();
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie"],
-            cookieName: "PARAGLIDE_LOCALE",
-            cookieDomain: "example.com",
-        },
+        strategy: ["cookie"],
+        cookieName: "PARAGLIDE_LOCALE",
+        cookieDomain: "example.com",
     });
     globalThis.document.cookie = "PARAGLIDE_LOCALE=en";
     runtime.setLocale("de");
@@ -92,21 +86,19 @@ test("url pattern strategy sets the window location", async () => {
     globalThis.window.location.hostname = "example.com";
     globalThis.window.location.reload = vi.fn();
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: { baseLocale: "en", locales: ["en", "de"] },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-            urlPatterns: [
-                {
-                    pattern: "https://example.:tld/:path*",
-                    localized: [
-                        ["en", "https://example.com/:path*"],
-                        ["de", "https://example.de/:path*"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["url"],
+        urlPatterns: [
+            {
+                pattern: "https://example.:tld/:path*",
+                localized: [
+                    ["en", "https://example.com/:path*"],
+                    ["de", "https://example.de/:path*"],
+                ],
+            },
+        ],
     });
     globalThis.window.location.href = "https://example.com/page";
     runtime.setLocale("de");
@@ -117,16 +109,14 @@ test("url pattern strategy sets the window location", async () => {
 // `!document.cookie` was used which returned false for an empty string
 test("sets the cookie when it's an empty string", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie"],
-            cookieName: "PARAGLIDE_LOCALE",
-        },
+        strategy: ["cookie"],
+        cookieName: "PARAGLIDE_LOCALE",
     });
     /** @ts-expect-error - client side api */
     globalThis.document = { cookie: "" };
@@ -135,26 +125,24 @@ test("sets the cookie when it's an empty string", async () => {
 });
 test("when strategy precedes URL, it should set the locale and re-direct to the URL", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie", "url", "baseLocale"],
-            cookieName: "PARAGLIDE_LOCALE",
-            isServer: "false",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/en/:path(.*)?",
-                    localized: [
-                        ["en", "https://example.com/en/:path(.*)?"],
-                        ["fr", "https://example.com/fr/:path(.*)?"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["cookie", "url", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+        isServer: "false",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/en/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
     });
     /** @ts-expect-error - client side api */
     globalThis.document = { cookie: "PARAGLIDE_LOCALE=fr" };
@@ -177,16 +165,14 @@ test("should not reload when setting locale to current locale", async () => {
     globalThis.window.location = { hostname: "example.com" };
     globalThis.window.location.reload = vi.fn();
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie"],
-            cookieName: "PARAGLIDE_LOCALE",
-        },
+        strategy: ["cookie"],
+        cookieName: "PARAGLIDE_LOCALE",
     });
     globalThis.document.cookie = "PARAGLIDE_LOCALE=en; path=/";
     // Setting to the current locale (en)
@@ -209,15 +195,13 @@ test("sets the locale to localStorage", async () => {
     // @ts-expect-error - global variable definition
     globalThis.window = {};
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["localStorage"],
-        },
+        strategy: ["localStorage"],
     });
     runtime.setLocale("de");
     expect(globalThis.localStorage.setItem).toHaveBeenCalledWith("PARAGLIDE_LOCALE", "de");
@@ -241,26 +225,24 @@ test("should set locale in all configured storage mechanisms regardless of which
     globalThis.window.location.reload = vi.fn();
     // Create runtime with multiple strategies
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url", "localStorage", "cookie", "baseLocale"],
-            cookieName: "PARAGLIDE_LOCALE",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:locale/:path*",
-                    localized: [
-                        ["en", "https://example.com/en/:path*"],
-                        ["de", "https://example.com/de/:path*"],
-                        ["fr", "https://example.com/fr/:path*"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["url", "localStorage", "cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:locale/:path*",
+                localized: [
+                    ["en", "https://example.com/en/:path*"],
+                    ["de", "https://example.com/de/:path*"],
+                    ["fr", "https://example.com/fr/:path*"],
+                ],
+            },
+        ],
     });
     // Call setLocale
     runtime.setLocale("fr");

package/dist/compiler/runtime/track-message-call.test.js

@@ -4,7 +4,7 @@ import { newProject } from "@inlang/sdk";
 import { test, expect } from "vitest";
 test("tracks message calls", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],

package/dist/compiler/server/middleware.d.ts

@@ -17,7 +17,7 @@
  *
  * @param {Request} request - The incoming request object
  * @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request
- *
+ * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
  * @returns {Promise<Response>}
  *
  * @example
@@ -62,5 +62,7 @@
 export function paraglideMiddleware<T>(request: Request, resolve: (args: {
     request: Request;
     locale: import("./runtime.js").Locale;
-}) => T | Promise<T>): Promise<Response>;
+}) => T | Promise<T>, callbacks?: {
+    onRedirect: (response: Response) => void;
+}): Promise<Response>;
 //# sourceMappingURL=middleware.d.ts.map

package/dist/compiler/server/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/server/middleware.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,oCA9Ca,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAEnF,OAAO,CAAC,QAAQ,CAAC,CA0H7B"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/server/middleware.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,oCA9Ca,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,cACrF;IAAE,UAAU,EAAC,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAA;CAAE,GACzC,OAAO,CAAC,QAAQ,CAAC,CA4H7B"}

package/dist/compiler/server/middleware.js

@@ -18,7 +18,7 @@ import * as runtime from "./runtime.js";
  *
  * @param {Request} request - The incoming request object
  * @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request
- *
+ * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
  * @returns {Promise<Response>}
  *
  * @example
@@ -60,7 +60,7 @@ import * as runtime from "./runtime.js";
  * };
  * ```
  */
-export async function paraglideMiddleware(request, resolve) {
+export async function paraglideMiddleware(request, resolve, callbacks) {
     if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
         const { AsyncLocalStorage } = await import("async_hooks");
         runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
@@ -76,7 +76,9 @@ export async function paraglideMiddleware(request, resolve) {
         runtime.strategy.includes("url")) {
         const localizedUrl = runtime.localizeUrl(request.url, { locale });
         if (normalizeURL(localizedUrl.href) !== normalizeURL(request.url)) {
-            return Response.redirect(localizedUrl, 307);
+            const response = Response.redirect(localizedUrl, 307);
+            callbacks?.onRedirect(response);
+            return response;
         }
     }
     // If the strategy includes "url", we need to de-localize the URL