@inlang/paraglide-js 2.0.11 → 2.0.12

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.test.js

@@ -3,15 +3,13 @@ import { createParaglide } from "../create-paraglide.js";
 import { newProject } from "@inlang/sdk";
 test("sets the locale and origin", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url", "globalVariable"],
-        },
+        strategy: ["url", "globalVariable"],
     });
     // setting the global variable to fr to assure that
     runtime.setLocale("fr");
@@ -37,15 +35,13 @@ test("sets the locale and origin", async () => {
 });
 test("delocalizes the url if the url strategy is used and returns the locale", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-        },
+        strategy: ["url"],
     });
     const request = new Request(new URL("https://example.com/de/page"), {
         headers: { "Sec-Fetch-Dest": "document" },
@@ -59,15 +55,13 @@ test("delocalizes the url if the url strategy is used and returns the locale", a
 });
 test("does not delocalize the url if the url strategy is not used", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["globalVariable", "baseLocale"],
-        },
+        strategy: ["globalVariable", "baseLocale"],
     });
     const request = new Request(new URL("https://example.com/de/page"), {
         headers: { "Sec-Fetch-Dest": "document" },
@@ -81,25 +75,23 @@ test("does not delocalize the url if the url strategy is not used", async () =>
 });
 test("redirects to localized URL when non-URL strategy determines locale", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie", "url"],
-            cookieName: "PARAGLIDE_LOCALE",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:path(.*)?",
-                    localized: [
-                        ["en", "https://example.com/en/:path(.*)?"],
-                        ["fr", "https://example.com/fr/:path(.*)?"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["cookie", "url"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
     });
     // Request to URL in en with cookie specifying French
     const request = new Request("https://example.com/en/some-path", {
@@ -119,25 +111,23 @@ test("redirects to localized URL when non-URL strategy determines locale", async
 });
 test("does not redirect if URL already matches determined locale", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie", "url"],
-            cookieName: "PARAGLIDE_LOCALE",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:path(.*)?",
-                    localized: [
-                        ["en", "https://example.com/en/:path(.*)?"],
-                        ["fr", "https://example.com/fr/:path(.*)?"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["cookie", "url"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
     });
     // Request to already localized URL matching cookie locale
     const request = new Request("https://example.com/fr/some-path", {
@@ -155,16 +145,14 @@ test("does not redirect if URL already matches determined locale", async () => {
 });
 test("works with disableAsyncLocalStorage option", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url", "globalVariable"],
-            disableAsyncLocalStorage: true,
-        },
+        strategy: ["url", "globalVariable"],
+        disableAsyncLocalStorage: true,
     });
     // Set a global locale to verify it doesn't interfere with request processing
     runtime.setLocale("fr");
@@ -189,15 +177,13 @@ test("works with disableAsyncLocalStorage option", async () => {
 });
 test("works with sequential parallel requests using disableAsyncLocalStorage", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url", "globalVariable"],
-        },
+        strategy: ["url", "globalVariable"],
     });
     // setting the global variable to fr to assure that
     runtime.setLocale("fr");
@@ -224,25 +210,23 @@ test("works with sequential parallel requests using disableAsyncLocalStorage", a
 // https://github.com/opral/inlang-paraglide-js/issues/442
 test("falls back to next strategy when cookie contains invalid locale", 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",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:path(.*)?",
-                    localized: [
-                        ["en", "https://example.com/en/:path(.*)?"],
-                        ["fr", "https://example.com/fr/:path(.*)?"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["cookie", "url", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
     });
     // Request with an invalid locale in cookie
     const request = new Request("https://example.com/fr/some-path", {
@@ -276,25 +260,23 @@ test("falls back to next strategy when cookie contains invalid locale", async ()
 test("prevents redirect loops by normalizing URLs with trailing slashes in different scenarios", async () => {
     // Create two different runtimes to test different strategy configurations
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie", "url"],
-            cookieName: "PARAGLIDE_LOCALE",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:path(.*)?",
-                    localized: [
-                        ["en", "https://example.com/en/:path(.*)?"],
-                        ["fr", "https://example.com/fr/:path(.*)?"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["cookie", "url"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
     });
     // SCENARIO 1: Basic trailing slash normalization with cookie strategy
     // Case 1A: Request URL has trailing slash, but localized URL might not
@@ -342,25 +324,23 @@ test("prevents redirect loops by normalizing URLs with trailing slashes in diffe
 // strategy: ["cookie", "url"]
 test.skip("doesn't redirect if disableUrlRedirect is true", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr"],
             },
         }),
-        compilerOptions: {
-            cookieName: "PARAGLIDE_LOCALE",
-            strategy: ["cookie", "url"],
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:path(.*)?",
-                    localized: [
-                        ["en", "https://example.com/en/:path(.*)?"],
-                        ["fr", "https://example.com/fr/:path(.*)?"],
-                    ],
-                },
-            ],
-        },
+        cookieName: "PARAGLIDE_LOCALE",
+        strategy: ["cookie", "url"],
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
     });
     // Create a request that would normally be redirected
     const request = new Request("https://example.com/en/some-path", {
@@ -382,25 +362,23 @@ test.skip("doesn't redirect if disableUrlRedirect is true", async () => {
 });
 test("only redirects if the request.headers.get('Sec-Fetch-Dest') === 'document'", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie", "url"],
-            cookieName: "PARAGLIDE_LOCALE",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:path(.*)?",
-                    localized: [
-                        ["en", "https://example.com/en/:path(.*)?"],
-                        ["fr", "https://example.com/fr/:path(.*)?"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["cookie", "url"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
     });
     // Test with Sec-Fetch-Dest = document (should redirect)
     const documentRequest = new Request("https://example.com/en/some-path", {
@@ -436,15 +414,13 @@ test("only redirects if the request.headers.get('Sec-Fetch-Dest') === 'document'
 // https://github.com/opral/inlang-paraglide-js/issues/477
 test("does not catch errors thrown by downstream resolve call", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-        },
+        strategy: ["url"],
     });
     await expect(() => runtime.paraglideMiddleware(new Request(new URL("https://example.com/page"), {
         headers: { "Sec-Fetch-Dest": "document" },

package/dist/services/env-variables/index.js

@@ -1,5 +1,5 @@
 export const ENV_VARIABLES = {
     PARJS_APP_ID: "library.inlang.paraglideJs",
     PARJS_POSTHOG_TOKEN: "phc_m5yJZCxjOGxF8CJvP5sQ3H0d76xpnLrsmiZHduT4jDz",
-    PARJS_PACKAGE_VERSION: "2.0.11",
+    PARJS_PACKAGE_VERSION: "2.0.12",
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -31,7 +31,7 @@
     "json5": "2.2.3",
     "unplugin": "^2.1.2",
     "urlpattern-polyfill": "^10.0.0",
-    "@inlang/sdk": "2.4.7",
+    "@inlang/sdk": "2.4.8",
     "@inlang/recommend-sherlock": "0.2.1"
   },
   "devDependencies": {
@@ -50,9 +50,9 @@
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.20.0",
     "vitest": "2.1.8",
+    "@inlang/paraglide-js": "2.0.12",
     "@inlang/plugin-message-format": "4.0.0",
-    "@opral/tsconfig": "1.1.0",
-    "@inlang/paraglide-js": "2.0.11"
+    "@opral/tsconfig": "1.1.0"
   },
   "keywords": [
     "inlang",