@inlang/paraglide-js 2.0.10 → 2.0.12

package/dist/compiler/runtime/extract-locale-from-url.test.js

@@ -3,23 +3,21 @@ import { createParaglide } from "../create-paraglide.js";
 import { newProject } from "@inlang/sdk";
 test("normal named groups", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/bookstore/item/:id",
-                    localized: [
-                        ["de", "https://example.com/buchladen/artikel/:id"],
-                        ["en", "https://example.com/bookstore/item/:id"],
-                    ],
-                },
-            ],
-        },
+        urlPatterns: [
+            {
+                pattern: "https://example.com/bookstore/item/:id",
+                localized: [
+                    ["de", "https://example.com/buchladen/artikel/:id"],
+                    ["en", "https://example.com/bookstore/item/:id"],
+                ],
+            },
+        ],
     });
     expect(runtime.extractLocaleFromUrl(`https://example.com/bookstore/item/123`)).toBe("en");
     expect(runtime.extractLocaleFromUrl(`https://example.com/buchladen/artikel/123`)).toBe("de");
@@ -27,23 +25,21 @@ test("normal named groups", async () => {
 });
 test("handles relative named groups", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            urlPatterns: [
-                {
-                    pattern: "/bookstore/item/:id",
-                    localized: [
-                        ["de", "/buchladen/artikel/:id"],
-                        ["en", "/bookstore/item/:id"],
-                    ],
-                },
-            ],
-        },
+        urlPatterns: [
+            {
+                pattern: "/bookstore/item/:id",
+                localized: [
+                    ["de", "/buchladen/artikel/:id"],
+                    ["en", "/bookstore/item/:id"],
+                ],
+            },
+        ],
     });
     expect(runtime.extractLocaleFromUrl(`https://example.com/bookstore/item/123`)).toBe("en");
     expect(runtime.extractLocaleFromUrl(`https://example.com/buchladen/artikel/123`)).toBe("de");
@@ -51,69 +47,63 @@ test("handles relative named groups", async () => {
 });
 test("wildcards", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            urlPatterns: [
-                {
-                    pattern: "https://{:subdomain.}?:domain.:tld/:path*",
-                    localized: [
-                        ["de", "https://de.:domain.:tld/startseite/ueber-uns"],
-                        ["en", "https://:domain.:tld/home/about-us"],
-                    ],
-                },
-            ],
-        },
+        urlPatterns: [
+            {
+                pattern: "https://{:subdomain.}?:domain.:tld/:path*",
+                localized: [
+                    ["de", "https://de.:domain.:tld/startseite/ueber-uns"],
+                    ["en", "https://:domain.:tld/home/about-us"],
+                ],
+            },
+        ],
     });
     expect(runtime.extractLocaleFromUrl(`https://de.example.com/startseite/ueber-uns`)).toBe("de");
     expect(runtime.extractLocaleFromUrl(`https://example.com/home/about-us`)).toBe("en");
 });
 test("optional parameters", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:locale?",
-                    localized: [
-                        ["de", "https://example.com/de"],
-                        ["en", "https://example.com/en"],
-                    ],
-                },
-            ],
-        },
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:locale?",
+                localized: [
+                    ["de", "https://example.com/de"],
+                    ["en", "https://example.com/en"],
+                ],
+            },
+        ],
     });
     expect(runtime.extractLocaleFromUrl(`https://example.com/de`)).toBe("de");
     expect(runtime.extractLocaleFromUrl(`https://example.com/en`)).toBe("en");
 });
 test("regex works", async () => {
     const { extractLocaleFromUrl } = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:item(phone)",
-                    localized: [
-                        ["en", "https://example.com/:item(phone)"],
-                        ["de", "https://example.com/de/:item(phone)"],
-                    ],
-                },
-            ],
-        },
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:item(phone)",
+                localized: [
+                    ["en", "https://example.com/:item(phone)"],
+                    ["de", "https://example.com/de/:item(phone)"],
+                ],
+            },
+        ],
     });
     expect(extractLocaleFromUrl(`https://example.com/de/phone`)).toBe("de");
     expect(extractLocaleFromUrl(`https://example.com/phone`)).toBe("en");
@@ -122,7 +112,7 @@ test("regex works", async () => {
 });
 test("default url pattern", async () => {
     const r = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],

package/dist/compiler/runtime/generate-static-localized-urls.test.js

@@ -4,17 +4,15 @@ import { newProject } from "@inlang/sdk";
 import "@inlang/paraglide-js/urlpattern-polyfill";
 test("generates localized URLs using default URL pattern", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-            // undefined creates the default pattern
-            urlPatterns: undefined,
-        },
+        strategy: ["url"],
+        // undefined creates the default pattern
+        urlPatterns: undefined,
     });
     const urls = runtime.generateStaticLocalizedUrls([
         "http://example.com/about",
@@ -38,31 +36,29 @@ test("generates localized URLs using default URL pattern", async () => {
 });
 test("generates localized URLs using custom URL patterns", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-            urlPatterns: [
-                {
-                    pattern: "/store/item/:id",
-                    localized: [
-                        ["en", "/store/item/:id"],
-                        ["de", "/laden/artikel/:id"],
-                    ],
-                },
-                {
-                    pattern: "/blog/:slug",
-                    localized: [
-                        ["en", "/blog/:slug"],
-                        ["de", "/blog/:slug"], // Same pattern for both locales
-                    ],
-                },
-            ],
-        },
+        strategy: ["url"],
+        urlPatterns: [
+            {
+                pattern: "/store/item/:id",
+                localized: [
+                    ["en", "/store/item/:id"],
+                    ["de", "/laden/artikel/:id"],
+                ],
+            },
+            {
+                pattern: "/blog/:slug",
+                localized: [
+                    ["en", "/blog/:slug"],
+                    ["de", "/blog/:slug"], // Same pattern for both locales
+                ],
+            },
+        ],
     });
     const urls = runtime.generateStaticLocalizedUrls([
         "https://example.com/store/item/123",
@@ -82,24 +78,22 @@ test("generates localized URLs using custom URL patterns", async () => {
 });
 test("handles paths that don't match any pattern by including them", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/store/:path*",
-                    localized: [
-                        ["en", "https://example.com/store/:path*"],
-                        ["de", "https://example.com/laden/:path*"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["url"],
+        urlPatterns: [
+            {
+                pattern: "https://example.com/store/:path*",
+                localized: [
+                    ["en", "https://example.com/store/:path*"],
+                    ["de", "https://example.com/laden/:path*"],
+                ],
+            },
+        ],
     });
     const urls = runtime.generateStaticLocalizedUrls([
         "https://example.com/store/item/123", // Should match pattern
@@ -118,24 +112,22 @@ test("handles paths that don't match any pattern by including them", async () =>
 });
 test("handles URL objects as input", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-            urlPatterns: [
-                {
-                    pattern: "/store/:path*",
-                    localized: [
-                        ["en", "/store/:path*"],
-                        ["de", "/laden/:path*"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["url"],
+        urlPatterns: [
+            {
+                pattern: "/store/:path*",
+                localized: [
+                    ["en", "/store/:path*"],
+                    ["de", "/laden/:path*"],
+                ],
+            },
+        ],
     });
     const urls = runtime.generateStaticLocalizedUrls([
         new URL("https://example.com/store/item/123?color=blue#reviews"),
@@ -156,17 +148,15 @@ test("handles URL objects as input", async () => {
 });
 test("generates localized URLs from paths", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de", "fr"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-            // undefined creates the default pattern
-            urlPatterns: undefined,
-        },
+        strategy: ["url"],
+        // undefined creates the default pattern
+        urlPatterns: undefined,
     });
     const urls = runtime.generateStaticLocalizedUrls([
         "/about",

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

@@ -4,16 +4,14 @@ import { createParaglide } from "../create-paraglide.js";
 test("matching by strategy works", async () => {
     const baseLocale = "en";
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale,
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie", "baseLocale"],
-            cookieName: "PARAGLIDE_LOCALE",
-        },
+        strategy: ["cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
     });
     // @ts-expect-error - global variable definition
     globalThis.document = {};
@@ -23,15 +21,13 @@ test("matching by strategy works", async () => {
 });
 test("throws if variable is used without baseLocale as fallback strategy", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["globalVariable"],
-        },
+        strategy: ["globalVariable"],
     });
     expect(() => runtime.getLocale()).toThrow();
     runtime.setLocale("de");
@@ -39,25 +35,23 @@ test("throws if variable is used without baseLocale as fallback strategy", async
 });
 test("retrieves the locale for a url pattern", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url"],
-            isServer: "false",
-            urlPatterns: [
-                {
-                    pattern: "https://example.:tld/:path*",
-                    localized: [
-                        ["en", "https://example.com/:path*"],
-                        ["de", "https://example.de/:path*"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["url"],
+        isServer: "false",
+        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" } };
     expect(runtime.getLocale()).toBe("en");
@@ -66,40 +60,36 @@ test("retrieves the locale for a url pattern", async () => {
 });
 test("url pattern strategy doesn't throw during SSR", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["url", "baseLocale"],
-            urlPatterns: [
-                {
-                    pattern: "https://example.:tld/:path*",
-                    localized: [
-                        ["en", "https://example.com/:path*"],
-                        ["de", "https://example.de/:path*"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["url", "baseLocale"],
+        urlPatterns: [
+            {
+                pattern: "https://example.:tld/:path*",
+                localized: [
+                    ["en", "https://example.com/:path*"],
+                    ["de", "https://example.de/:path*"],
+                ],
+            },
+        ],
     });
     expect(() => runtime.getLocale()).not.toThrow();
 });
 test("doesn't throw for an old cookie locale", async () => {
     const baseLocale = "en";
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["cookie", "baseLocale"],
-            cookieName: "PARAGLIDE_LOCALE",
-        },
+        strategy: ["cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
     });
     // @ts-expect-error - global variable definition
     globalThis.document = {};
@@ -110,16 +100,14 @@ test("doesn't throw for an old cookie locale", async () => {
 test("returns the preferred locale from navigator.languages", async () => {
     const originalNavigator = globalThis.navigator;
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "fr", "de"],
             },
         }),
-        compilerOptions: {
-            isServer: "false",
-            strategy: ["preferredLanguage"],
-        },
+        isServer: "false",
+        strategy: ["preferredLanguage"],
     });
     // Mock navigator.languages
     Object.defineProperty(globalThis, "navigator", {
@@ -137,17 +125,15 @@ test("returns the preferred locale from navigator.languages", async () => {
 });
 test("returns the locale from local storage", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {
-            strategy: ["localStorage"],
-            localStorageKey: "PARAGLIDE_LOCALE",
-            isServer: "false",
-        },
+        strategy: ["localStorage"],
+        localStorageKey: "PARAGLIDE_LOCALE",
+        isServer: "false",
     });
     // @ts-expect-error - global variable definition
     globalThis.localStorage = {
@@ -159,32 +145,31 @@ test("returns the locale from local storage", async () => {
 test("initially sets the locale after resolving it for the first time", async () => {
     // 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", "cookie"],
-            isServer: "false",
-            cookieName: "PARAGLIDE_LOCALE",
-            urlPatterns: [
-                {
-                    pattern: "https://example.com/:path*",
-                    localized: [
-                        ["en", "https://example.com/en/:path*"],
-                        ["de", "https://example.com/de/:path*"],
-                        ["fr", "https://example.com/fr/:path*"],
-                    ],
-                },
-            ],
-        },
+        strategy: ["url", "cookie"],
+        isServer: "false",
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path*",
+                localized: [
+                    ["en", "https://example.com/en/:path*"],
+                    ["de", "https://example.com/de/:path*"],
+                    ["fr", "https://example.com/fr/:path*"],
+                ],
+            },
+        ],
     });
     // Setup global objects for URL strategy
     globalThis.window = {
         // @ts-expect-error - global variable definition
         location: {
+            hostname: "example.com",
             href: "https://example.com/de/page",
         },
     };
@@ -195,6 +180,6 @@ test("initially sets the locale after resolving it for the first time", async ()
     // First call to getLocale should resolve and set the locale
     expect(runtime.getLocale()).toBe("de");
     // Cookie should be set, proving that the locale was initially set
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=de; path=/; max-age=34560000");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=de; path=/; max-age=34560000; domain=example.com");
     expect(globalThis.window.location.href).toBe("https://example.com/de/page");
 });

package/dist/compiler/runtime/get-url-origin.test.js

@@ -3,25 +3,23 @@ import { createParaglide } from "../create-paraglide.js";
 import { newProject } from "@inlang/sdk";
 test("returns a placeholder in server environment as placeholder to make dependent apis work", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {},
     });
     expect(runtime.getUrlOrigin()).toBeDefined();
 });
 test("returns the window.location.origin if available", async () => {
     const runtime = await createParaglide({
-        project: await newProject({
+        blob: await newProject({
             settings: {
                 baseLocale: "en",
                 locales: ["en", "de"],
             },
         }),
-        compilerOptions: {},
     });
     globalThis.window = { location: { origin: "https://example.com" } };
     expect(runtime.getUrlOrigin()).toBe("https://example.com");