@inlang/paraglide-js 2.1.0 → 2.2.0

package/dist/bundler-plugins/vite.d.ts

@@ -1,2 +1,2 @@
-export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
+export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("unplugin").VitePlugin<any> | import("unplugin").VitePlugin<any>[];
 //# sourceMappingURL=vite.d.ts.map

package/dist/bundler-plugins/vite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/vite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,+GAAoC,CAAC"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/vite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,+HAAoC,CAAC"}

package/dist/compiler/compiler-options.d.ts

@@ -106,10 +106,22 @@ export type CompilerOptions = {
     cookieMaxAge?: number;
     /**
      * The host to which the cookie will be sent.
-     * If null, this defaults to the host portion of the current document location and the cookie is not available on subdomains.
-     * Otherwise, subdomains are always included.
+     * If undefined or empty, the domain attribute is omitted from the cookie, scoping it to the exact current domain only (no subdomains).
+     * If specified, the cookie will be available to the specified domain and all its subdomains.
      *
-     * @default window.location.hostname
+     * Use this when you need cookies to be shared across subdomains (e.g., between `app.example.com` and `api.example.com`).
+     * The default behavior (no domain) ensures better compatibility with server-side cookies that don't specify a domain attribute.
+     *
+     * @example
+     * ```ts
+     * // Default: exact domain only (compatible with server-side cookies)
+     * cookieDomain: undefined // Cookie: "PARAGLIDE_LOCALE=en; path=/; max-age=34560000"
+     *
+     * // Subdomain sharing: available across all subdomains
+     * cookieDomain: "example.com" // Cookie: "PARAGLIDE_LOCALE=en; path=/; max-age=34560000; domain=example.com"
+     * ```
+     *
+     * @default "" (no domain attribute, exact domain only)
      */
     cookieDomain?: string;
     /**

package/dist/compiler/compiler-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler-options.d.ts","sourceRoot":"","sources":["../../src/compiler/compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CAcU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;OAcG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;IAChD;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;;;;;;OASG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,EAAE,CAAC,EAAE,GAAG,CAAC;CACT,CAAC"}
+{"version":3,"file":"compiler-options.d.ts","sourceRoot":"","sources":["../../src/compiler/compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CAcU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;OAcG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;IAChD;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;;;;;;OASG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,EAAE,CAAC,EAAE,GAAG,CAAC;CACT,CAAC"}

package/dist/compiler/runtime/create-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/create-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,EAAE;QAChB,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;QACnD,UAAU,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;QACvD,YAAY,EAAE,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC,CAAC;QAC3D,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;QAC9C,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;QAC7C,qCAAqC,EAAE,eAAe,CAAC,uCAAuC,CAAC,CAAC;QAChG,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACtC,eAAe,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC;QACpD,wBAAwB,EAAE,WAAW,CACpC,eAAe,CAAC,0BAA0B,CAAC,CAC3C,CAAC;KACF,CAAC;CACF,GAAG,MAAM,CAwIT"}
+{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/create-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,EAAE;QAChB,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;QACnD,UAAU,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;QACvD,YAAY,EAAE,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC,CAAC;QAC3D,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;QAC9C,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;QAC7C,qCAAqC,EAAE,eAAe,CAAC,uCAAuC,CAAC,CAAC;QAChG,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACtC,eAAe,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC;QACpD,wBAAwB,EAAE,WAAW,CACpC,eAAe,CAAC,0BAA0B,CAAC,CAC3C,CAAC;KACF,CAAC;CACF,GAAG,MAAM,CA0IT"}

package/dist/compiler/runtime/create-runtime.js

@@ -62,6 +62,8 @@ ${injectCode("./assert-is-locale.js")}
 
 ${injectCode("./extract-locale-from-request.js")}
 
+${injectCode("./extract-locale-from-request-async.js")}
+
 ${injectCode("./extract-locale-from-cookie.js")}
 
 ${injectCode("./extract-locale-from-header.js")}

package/dist/compiler/runtime/extract-locale-from-request-async.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Asynchronously extracts a locale from a request.
+ *
+ * This function supports async custom server strategies, unlike the synchronous
+ * `extractLocaleFromRequest`. Use this function when you have custom server strategies
+ * that need to perform asynchronous operations (like database calls) in their getLocale method.
+ *
+ * The function first processes any custom server strategies asynchronously, then falls back
+ * to the synchronous `extractLocaleFromRequest` for all other strategies.
+ *
+ * @see {@link https://github.com/opral/inlang-paraglide-js/issues/527#issuecomment-2978151022}
+ *
+ * @example
+ *   // Basic usage
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @example
+ *   // With custom async server strategy
+ *   defineCustomServerStrategy("custom-database", {
+ *     getLocale: async (request) => {
+ *       const userId = extractUserIdFromRequest(request);
+ *       return await getUserLocaleFromDatabase(userId);
+ *     }
+ *   });
+ *
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @type {(request: Request) => Promise<Locale>}
+ */
+export const extractLocaleFromRequestAsync: (request: Request) => Promise<Locale>;
+//# sourceMappingURL=extract-locale-from-request-async.d.ts.map

package/dist/compiler/runtime/extract-locale-from-request-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-locale-from-request-async.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request-async.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4CAFU,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,CAyB7C"}

package/dist/compiler/runtime/extract-locale-from-request-async.js

@@ -0,0 +1,55 @@
+import { customServerStrategies, isCustomStrategy } from "./strategy.js";
+import { strategy } from "./variables.js";
+import { assertIsLocale } from "./assert-is-locale.js";
+import { isLocale } from "./is-locale.js";
+import { extractLocaleFromRequest } from "./extract-locale-from-request.js";
+/**
+ * Asynchronously extracts a locale from a request.
+ *
+ * This function supports async custom server strategies, unlike the synchronous
+ * `extractLocaleFromRequest`. Use this function when you have custom server strategies
+ * that need to perform asynchronous operations (like database calls) in their getLocale method.
+ *
+ * The function first processes any custom server strategies asynchronously, then falls back
+ * to the synchronous `extractLocaleFromRequest` for all other strategies.
+ *
+ * @see {@link https://github.com/opral/inlang-paraglide-js/issues/527#issuecomment-2978151022}
+ *
+ * @example
+ *   // Basic usage
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @example
+ *   // With custom async server strategy
+ *   defineCustomServerStrategy("custom-database", {
+ *     getLocale: async (request) => {
+ *       const userId = extractUserIdFromRequest(request);
+ *       return await getUserLocaleFromDatabase(userId);
+ *     }
+ *   });
+ *
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @type {(request: Request) => Promise<Locale>}
+ */
+export const extractLocaleFromRequestAsync = async (request) => {
+    /** @type {string|undefined} */
+    let locale;
+    // Process custom strategies first, in order
+    for (const strat of strategy) {
+        if (isCustomStrategy(strat) && customServerStrategies.has(strat)) {
+            const handler = customServerStrategies.get(strat);
+            if (handler) {
+                /** @type {string|undefined} */
+                locale = await handler.getLocale(request);
+            }
+            // If we got a valid locale from this custom strategy, use it
+            if (locale !== undefined && isLocale(locale)) {
+                return assertIsLocale(locale);
+            }
+        }
+    }
+    // If no custom strategy provided a valid locale, fall back to sync version
+    locale = extractLocaleFromRequest(request);
+    return assertIsLocale(locale);
+};

package/dist/compiler/runtime/extract-locale-from-request-async.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extract-locale-from-request-async.test.d.ts.map

package/dist/compiler/runtime/extract-locale-from-request-async.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-locale-from-request-async.test.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request-async.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,58 @@
+import { newProject } from "@inlang/sdk";
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
+test("returns locale from custom strategy which is async", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-header", "baseLocale"],
+    });
+    class FakeDB {
+        db = new Map();
+        constructor() {
+            this.db.set("1", "fr");
+        }
+        async getUserLocaleById(id) {
+            return this.db.get(id);
+        }
+    }
+    const db = new FakeDB();
+    async function getLocaleFromUserRequest(request) {
+        const userId = request?.headers.get("X-Custom-User-ID") ?? undefined;
+        if (!userId)
+            throw Error("No User ID");
+        const locale = await db.getUserLocaleById(userId);
+        return locale;
+    }
+    runtime.defineCustomServerStrategy("custom-header", {
+        getLocale: async (request) => (await getLocaleFromUserRequest(request)) ?? undefined,
+    });
+    const request = new Request("http://example.com", {
+        headers: {
+            "X-Custom-User-ID": "1",
+        },
+    });
+    const locale = await runtime.extractLocaleFromRequestAsync(request);
+    expect(locale).toBe("fr");
+});
+test("falls back to next strategy when custom strategy returns undefined", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["custom-fallback", "baseLocale"],
+    });
+    runtime.defineCustomServerStrategy("custom-fallback", {
+        getLocale: () => undefined,
+    });
+    const request = new Request("http://example.com");
+    const locale = await runtime.extractLocaleFromRequestAsync(request);
+    expect(locale).toBe("en"); // Should fall back to baseLocale
+});

package/dist/compiler/runtime/extract-locale-from-request.d.ts

@@ -8,6 +8,9 @@
  * they are defined. If a strategy returns an invalid locale,
  * it will fall back to the next strategy.
  *
+ * Note: Custom server strategies are not supported in this synchronous version.
+ * Use `extractLocaleFromRequestAsync` if you need custom server strategies with async getLocale methods.
+ *
  * @example
  *   const locale = extractLocaleFromRequest(request);
  *

package/dist/compiler/runtime/extract-locale-from-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAyCpC"}
+{"version":3,"file":"extract-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAFU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CA0CpC"}

package/dist/compiler/runtime/extract-locale-from-request.js

@@ -2,7 +2,7 @@ import { assertIsLocale } from "./assert-is-locale.js";
 import { extractLocaleFromHeader } from "./extract-locale-from-header.js";
 import { extractLocaleFromUrl } from "./extract-locale-from-url.js";
 import { isLocale } from "./is-locale.js";
-import { customServerStrategies, isCustomStrategy } from "./strategy.js";
+import { isCustomStrategy } from "./strategy.js";
 import { baseLocale, cookieName, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED, TREE_SHAKE_URL_STRATEGY_USED, } from "./variables.js";
 /**
  * Extracts a locale from a request.
@@ -14,6 +14,9 @@ import { baseLocale, cookieName, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE
  * they are defined. If a strategy returns an invalid locale,
  * it will fall back to the next strategy.
  *
+ * Note: Custom server strategies are not supported in this synchronous version.
+ * Use `extractLocaleFromRequestAsync` if you need custom server strategies with async getLocale methods.
+ *
  * @example
  *   const locale = extractLocaleFromRequest(request);
  *
@@ -46,9 +49,10 @@ export const extractLocaleFromRequest = (request) => {
         else if (strat === "localStorage") {
             continue;
         }
-        else if (isCustomStrategy(strat) && customServerStrategies.has(strat)) {
-            const handler = customServerStrategies.get(strat);
-            locale = handler.getLocale(request);
+        else if (isCustomStrategy(strat)) {
+            // Custom strategies are not supported in sync version
+            // Use extractLocaleFromRequestAsync for custom server strategies
+            continue;
         }
         if (locale !== undefined) {
             if (!isLocale(locale)) {

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

@@ -238,7 +238,7 @@ test("preferredLanguage precedence over url", async () => {
     const locale = runtime.extractLocaleFromRequest(request);
     expect(locale).toBe("de");
 });
-test("returns locale from custom strategy", async () => {
+test("sync version no longer supports custom strategies", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
             settings: {
@@ -257,10 +257,11 @@ test("returns locale from custom strategy", async () => {
             "X-Custom-Locale": "fr",
         },
     });
+    // Sync version skips custom strategies and falls back to baseLocale
     const locale = runtime.extractLocaleFromRequest(request);
-    expect(locale).toBe("fr");
+    expect(locale).toBe("en"); // baseLocale fallback
 });
-test("falls back to next strategy when custom strategy returns undefined", async () => {
+test("sync version skips custom strategy and falls back to next built-in strategy", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
             settings: {
@@ -275,9 +276,9 @@ test("falls back to next strategy when custom strategy returns undefined", async
     });
     const request = new Request("http://example.com");
     const locale = runtime.extractLocaleFromRequest(request);
-    expect(locale).toBe("en"); // Should fall back to baseLocale
+    expect(locale).toBe("en"); // Should fall back to baseLocale (skipping custom strategy)
 });
-test("custom strategy takes precedence over built-in strategies", async () => {
+test("sync version uses built-in strategies instead of custom strategies", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
             settings: {
@@ -297,9 +298,9 @@ test("custom strategy takes precedence over built-in strategies", async () => {
         },
     });
     const locale = runtime.extractLocaleFromRequest(request);
-    expect(locale).toBe("de"); // Should use custom strategy, not cookie
+    expect(locale).toBe("fr"); // Should use cookie since custom strategy is skipped in sync version
 });
-test("multiple custom strategies work in order", async () => {
+test("sync version skips all custom strategies and uses baseLocale", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
             settings: {
@@ -317,5 +318,5 @@ test("multiple custom strategies work in order", async () => {
     });
     const request = new Request("http://example.com");
     const locale = runtime.extractLocaleFromRequest(request);
-    expect(locale).toBe("fr"); // Should use second custom strategy
+    expect(locale).toBe("en"); // Should skip all custom strategies and use baseLocale
 });

package/dist/compiler/runtime/get-locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/get-locale.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;GAWG;AACH,sBAFU,MAAM,MAAM,CAiEpB;AAEF;;;;;;;;;;;;;;GAcG;AACH,iCAFU,CAAC,EAAE,EAAE,MAAM,MAAM,KAAK,IAAI,CAIlC"}
+{"version":3,"file":"get-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/get-locale.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;GAWG;AACH,sBAFU,MAAM,MAAM,CAyEpB;AAEF;;;;;;;;;;;;;;GAcG;AACH,iCAFU,CAAC,EAAE,EAAE,MAAM,MAAM,KAAK,IAAI,CAIlC"}

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

@@ -69,7 +69,15 @@ export let getLocale = () => {
         }
         else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
             const handler = customClientStrategies.get(strat);
-            locale = handler.getLocale();
+            if (handler) {
+                const result = handler.getLocale();
+                // Handle both sync and async results - skip async in sync getLocale
+                if (result instanceof Promise) {
+                    // Can't await in sync function, skip async strategies
+                    continue;
+                }
+                locale = result;
+            }
         }
         // check if match, else continue loop
         if (locale !== undefined) {

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

@@ -180,7 +180,7 @@ 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; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=de; path=/; max-age=34560000");
     expect(globalThis.window.location.href).toBe("https://example.com/de/page");
 });
 test("returns locale from custom strategy", async () => {

package/dist/compiler/runtime/set-locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/set-locale.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;GAeG;AACH,sBAFU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,IAAI,CAqFnE;AAgBK,uCAFI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,QAIrC"}
+{"version":3,"file":"set-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/set-locale.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;GAeG;AACH,sBAFU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,IAAI,CA8FnE;AAgBK,uCAFI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,QAIrC"}

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

@@ -47,9 +47,11 @@ export let setLocale = (newLocale, options) => {
                 typeof window === "undefined") {
                 continue;
             }
-            const domain = cookieDomain || window.location.hostname;
             // set the cookie
-            document.cookie = `${cookieName}=${newLocale}; path=/; max-age=${cookieMaxAge}; domain=${domain}`;
+            const cookieString = `${cookieName}=${newLocale}; path=/; max-age=${cookieMaxAge}`;
+            document.cookie = cookieDomain
+                ? `${cookieString}; domain=${cookieDomain}`
+                : cookieString;
         }
         else if (strat === "baseLocale") {
             // nothing to be set here. baseLocale is only a fallback
@@ -78,7 +80,15 @@ export let setLocale = (newLocale, options) => {
         }
         else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
             const handler = customClientStrategies.get(strat);
-            handler.setLocale(newLocale);
+            if (handler) {
+                const result = handler.setLocale(newLocale);
+                // Handle async setLocale - fire and forget
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        console.warn(`Custom strategy "${strat}" setLocale failed:`, error);
+                    });
+                }
+            }
         }
     }
     if (!isServer &&

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

@@ -22,7 +22,7 @@ test("sets the cookie to a different locale", async () => {
     globalThis.document.cookie = "PARAGLIDE_LOCALE=en";
     runtime.setLocale("de");
     // set the locale
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=de; path=/; max-age=34560000; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=de; path=/; max-age=34560000");
     // reloads the site if window is available
     expect(globalThis.window.location.reload).toBeCalled();
 });
@@ -121,7 +121,7 @@ test("sets the cookie when it's an empty string", async () => {
     /** @ts-expect-error - client side api */
     globalThis.document = { cookie: "" };
     runtime.setLocale("en");
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=en; path=/; max-age=34560000; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=en; path=/; max-age=34560000");
 });
 test("when strategy precedes URL, it should set the locale and re-direct to the URL", async () => {
     const runtime = await createParaglide({
@@ -152,7 +152,7 @@ test("when strategy precedes URL, it should set the locale and re-direct to the
     // Cookie strategy should determine locale as French
     expect(runtime.getLocale()).toBe("fr");
     runtime.setLocale("en");
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=en; path=/; max-age=34560000; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=en; path=/; max-age=34560000");
     expect(globalThis.window.location.href).toBe("https://example.com/en/some-path");
 });
 // https://github.com/opral/inlang-paraglide-js/issues/430
@@ -178,12 +178,12 @@ test("should not reload when setting locale to current locale", async () => {
     // Setting to the current locale (en)
     runtime.setLocale("en");
     // Cookie should remain unchanged
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=en; path=/; max-age=34560000; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=en; path=/; max-age=34560000");
     // Should not trigger a reload
     expect(globalThis.window.location.reload).not.toBeCalled();
     // Setting to a different locale should still work
     runtime.setLocale("de");
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=de; path=/; max-age=34560000; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=de; path=/; max-age=34560000");
     expect(globalThis.window.location.reload).toBeCalled();
 });
 test("sets the locale to localStorage", async () => {
@@ -249,7 +249,7 @@ test("should set locale in all configured storage mechanisms regardless of which
     // Verify that all storage mechanisms are updated
     expect(globalThis.window.location.href).toBe("https://example.com/fr/page");
     expect(globalThis.localStorage.setItem).toHaveBeenCalledWith("PARAGLIDE_LOCALE", "fr");
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=fr; path=/; max-age=34560000; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=fr; path=/; max-age=34560000");
 });
 test("calls setLocale on custom strategy", async () => {
     let customLocale = "en";
@@ -350,7 +350,7 @@ test("custom strategy setLocale works with cookie and localStorage", async () =>
     runtime.setLocale("fr");
     expect(customData).toBe("fr");
     expect(globalThis.localStorage.setItem).toHaveBeenCalledWith("PARAGLIDE_LOCALE", "fr");
-    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=fr; path=/; max-age=34560000; domain=example.com");
+    expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=fr; path=/; max-age=34560000");
 });
 test("custom strategy setLocale integrates with URL strategy", async () => {
     let customStoredLocale = "en";

package/dist/compiler/runtime/strategy.d.ts

@@ -2,27 +2,25 @@
  * Checks if the given strategy is a custom strategy.
  *
  * @param {any} strategy The name of the custom strategy to validate.
- * Must be a string that starts with "custom-" followed by alphanumeric characters.
+ * Must be a string that starts with "custom-" followed by alphanumeric characters, hyphens, or underscores.
  * @returns {boolean} Returns true if it is a custom strategy, false otherwise.
  */
 export function isCustomStrategy(strategy: any): boolean;
 /**
  * Defines a custom strategy that is executed on the server.
  *
- * @param {any} strategy The name of the custom strategy to define. Must follow the pattern `custom-<name>` where
- * `<name>` contains only alphanumeric characters.
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
  * @param {CustomServerStrategyHandler} handler The handler for the custom strategy, which should implement
- * the method `getLocale`.
+ * the method getLocale.
  * @returns {void}
  */
 export function defineCustomServerStrategy(strategy: any, handler: CustomServerStrategyHandler): void;
 /**
  * Defines a custom strategy that is executed on the client.
  *
- * @param {any} strategy The name of the custom strategy to define. Must follow the pattern `custom-<name>` where
- * `<name>` contains only alphanumeric characters.
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
  * @param {CustomClientStrategyHandler} handler The handler for the custom strategy, which should implement the
- * methods `getLocale` and `setLocale`.
+ * methods getLocale and setLocale.
  * @returns {void}
  */
 export function defineCustomClientStrategy(strategy: any, handler: CustomClientStrategyHandler): void;
@@ -39,22 +37,24 @@ export function defineCustomClientStrategy(strategy: any, handler: CustomClientS
  * @typedef {Array<Strategy>} Strategies
  */
 /**
- * @typedef {{ getLocale: (request?: Request) => string | undefined }} CustomServerStrategyHandler
+ * @typedef {{ getLocale: (request?: Request) => Promise<string | undefined> | (string | undefined) }} CustomServerStrategyHandler
  */
 /**
- * @typedef {{ getLocale: () => string | undefined, setLocale: (locale: string) => void }} CustomClientStrategyHandler
+ * @typedef {{ getLocale: () => Promise<string|undefined> | (string | undefined), setLocale: (locale: string) => Promise<void> | void }} CustomClientStrategyHandler
  */
-export const customServerStrategies: Map<any, any>;
-export const customClientStrategies: Map<any, any>;
+/** @type {Map<string, CustomServerStrategyHandler>} */
+export const customServerStrategies: Map<string, CustomServerStrategyHandler>;
+/** @type {Map<string, CustomClientStrategyHandler>} */
+export const customClientStrategies: Map<string, CustomClientStrategyHandler>;
 export type BuiltInStrategy = "cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage";
 export type CustomStrategy = `custom_${string}`;
 export type Strategy = BuiltInStrategy | CustomStrategy;
 export type Strategies = Array<Strategy>;
 export type CustomServerStrategyHandler = {
-    getLocale: (request?: Request) => string | undefined;
+    getLocale: (request?: Request) => Promise<string | undefined> | (string | undefined);
 };
 export type CustomClientStrategyHandler = {
-    getLocale: () => string | undefined;
-    setLocale: (locale: string) => void;
+    getLocale: () => Promise<string | undefined> | (string | undefined);
+    setLocale: (locale: string) => Promise<void> | void;
 };
 //# sourceMappingURL=strategy.d.ts.map

package/dist/compiler/runtime/strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/strategy.js"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH,2CAJW,GAAG,GAED,OAAO,CAInB;AAED;;;;;;;;GAQG;AACH,qDANW,GAAG,WAEH,2BAA2B,GAEzB,IAAI,CAWhB;AAED;;;;;;;;GAQG;AACH,qDANW,GAAG,WAEH,2BAA2B,GAEzB,IAAI,CAWhB;AA5ED;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH,mDAAgD;AAChD,mDAAgD;8BAxBnC,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,KAAK,GAAG,mBAAmB,GAAG,cAAc;6BAIzF,UAAU,MAAM,EAAE;uBAIlB,eAAe,GAAG,cAAc;yBAIhC,KAAK,CAAC,QAAQ,CAAC;0CAIf;IAAE,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAA;CAAE;0CAIxD;IAAE,SAAS,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE"}
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/strategy.js"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,2CAJW,GAAG,GAED,OAAO,CAMnB;AAED;;;;;;;GAOG;AACH,qDALW,GAAG,WACH,2BAA2B,GAEzB,IAAI,CAUhB;AAED;;;;;;;GAOG;AACH,qDALW,GAAG,WACH,2BAA2B,GAEzB,IAAI,CAUhB;AA5ED;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH,uDAAuD;AACvD,qCADW,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,CACH;AAChD,uDAAuD;AACvD,qCADW,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,CACH;8BA1BnC,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,KAAK,GAAG,mBAAmB,GAAG,cAAc;6BAIzF,UAAU,MAAM,EAAE;uBAIlB,eAAe,GAAG,cAAc;yBAIhC,KAAK,CAAC,QAAQ,CAAC;0CAIf;IAAE,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAAE;0CAIxF;IAAE,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,GAAC,SAAS,CAAC,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAAE"}

package/dist/compiler/runtime/strategy.js

@@ -11,52 +11,50 @@
  * @typedef {Array<Strategy>} Strategies
  */
 /**
- * @typedef {{ getLocale: (request?: Request) => string | undefined }} CustomServerStrategyHandler
+ * @typedef {{ getLocale: (request?: Request) => Promise<string | undefined> | (string | undefined) }} CustomServerStrategyHandler
  */
 /**
- * @typedef {{ getLocale: () => string | undefined, setLocale: (locale: string) => void }} CustomClientStrategyHandler
+ * @typedef {{ getLocale: () => Promise<string|undefined> | (string | undefined), setLocale: (locale: string) => Promise<void> | void }} CustomClientStrategyHandler
  */
+/** @type {Map<string, CustomServerStrategyHandler>} */
 export const customServerStrategies = new Map();
+/** @type {Map<string, CustomClientStrategyHandler>} */
 export const customClientStrategies = new Map();
 /**
  * Checks if the given strategy is a custom strategy.
  *
  * @param {any} strategy The name of the custom strategy to validate.
- * Must be a string that starts with "custom-" followed by alphanumeric characters.
+ * Must be a string that starts with "custom-" followed by alphanumeric characters, hyphens, or underscores.
  * @returns {boolean} Returns true if it is a custom strategy, false otherwise.
  */
 export function isCustomStrategy(strategy) {
-    return typeof strategy === "string" && /^custom-[A-Za-z0-9]+$/.test(strategy);
+    return (typeof strategy === "string" && /^custom-[A-Za-z0-9_-]+$/.test(strategy));
 }
 /**
  * Defines a custom strategy that is executed on the server.
  *
- * @param {any} strategy The name of the custom strategy to define. Must follow the pattern `custom-<name>` where
- * `<name>` contains only alphanumeric characters.
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
  * @param {CustomServerStrategyHandler} handler The handler for the custom strategy, which should implement
- * the method `getLocale`.
+ * the method getLocale.
  * @returns {void}
  */
 export function defineCustomServerStrategy(strategy, handler) {
     if (!isCustomStrategy(strategy)) {
-        throw new Error(`Invalid custom strategy: "${strategy}". Must be a custom strategy following the pattern custom-<name>` +
-            " where <name> contains only alphanumeric characters.");
+        throw new Error(`Invalid custom strategy: "${strategy}". Must be a custom strategy following the pattern custom-name.`);
     }
     customServerStrategies.set(strategy, handler);
 }
 /**
  * Defines a custom strategy that is executed on the client.
  *
- * @param {any} strategy The name of the custom strategy to define. Must follow the pattern `custom-<name>` where
- * `<name>` contains only alphanumeric characters.
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
  * @param {CustomClientStrategyHandler} handler The handler for the custom strategy, which should implement the
- * methods `getLocale` and `setLocale`.
+ * methods getLocale and setLocale.
  * @returns {void}
  */
 export function defineCustomClientStrategy(strategy, handler) {
     if (!isCustomStrategy(strategy)) {
-        throw new Error(`Invalid custom strategy: "${strategy}". Must be a custom strategy following the pattern custom-<name>` +
-            " where <name> contains only alphanumeric characters.");
+        throw new Error(`Invalid custom strategy: "${strategy}". Must be a custom strategy following the pattern custom-name.`);
     }
     customClientStrategies.set(strategy, handler);
 }

package/dist/compiler/runtime/strategy.test.js

@@ -21,8 +21,10 @@ describe("isCustomStrategy", () => {
         expect(isCustomStrategy("custom-")).toBe(false);
         expect(isCustomStrategy("header")).toBe(false);
         expect(isCustomStrategy("custom")).toBe(false);
-        expect(isCustomStrategy("custom-invalid-name")).toBe(false);
-        expect(isCustomStrategy("custom-invalid_name")).toBe(false);
+        // These are now valid with our relaxed pattern:
+        expect(isCustomStrategy("custom-invalid-name")).toBe(true);
+        expect(isCustomStrategy("custom-invalid_name")).toBe(true);
+        // But spaces and special chars are still invalid:
         expect(isCustomStrategy("custom-invalid name")).toBe(false);
         expect(isCustomStrategy("custom-invalid@")).toBe(false);
         expect(isCustomStrategy("Custom-header")).toBe(false);
@@ -62,14 +64,12 @@ describe.each([
     const defaultHandler = { getLocale: () => "en", setLocale: () => { } };
     const invalidInputs = [
         ["", "empty name"],
-        ["invalid-name", "names with hyphens"],
-        ["invalid_name", "names with underscores"],
         ["@invalid", "names with special characters (@)"],
         ["invalid!", "names with special characters (!)"],
         ["inva lid", "names with spaces"],
     ];
     test.each(invalidInputs)(`${strategyName} throws error for %s (%s)`, (input) => {
-        expect(() => defineStrategy(input, defaultHandler)).toThrow(`Invalid custom strategy: "${input}". Must be a custom strategy following the pattern custom-<name> where <name> contains only alphanumeric characters.`);
+        expect(() => defineStrategy(input, defaultHandler)).toThrow(`Invalid custom strategy: "${input}". Must be a custom strategy following the pattern custom-name.`);
     });
     test(`${strategyName} should compile with custom strategies in strategy array`, async () => {
         // Test that compile accepts custom strategies

package/dist/compiler/runtime/type.d.ts

@@ -27,6 +27,7 @@ export type Runtime = {
     deLocalizeUrl: typeof import("./localize-url.js").deLocalizeUrl;
     extractLocaleFromUrl: typeof import("./extract-locale-from-url.js").extractLocaleFromUrl;
     extractLocaleFromRequest: typeof import("./extract-locale-from-request.js").extractLocaleFromRequest;
+    extractLocaleFromRequestAsync: typeof import("./extract-locale-from-request-async.js").extractLocaleFromRequestAsync;
     extractLocaleFromCookie: typeof import("./extract-locale-from-cookie.js").extractLocaleFromCookie;
     extractLocaleFromHeader: typeof import("./extract-locale-from-header.js").extractLocaleFromHeader;
     extractLocaleFromNavigator: typeof import("./extract-locale-from-navigator.js").extractLocaleFromNavigator;

package/dist/compiler/runtime/type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/type.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,OAAO,EAAE,cAAc,gBAAgB,EAAE,OAAO,CAAC;IACjD,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,YAAY,EAAE,cAAc,gBAAgB,EAAE,YAAY,CAAC;IAC3D,WAAW,EAAE,cAAc,gBAAgB,EAAE,WAAW,CAAC;IACzD,wBAAwB,EAAE,cAAc,gBAAgB,EAAE,wBAAwB,CAAC;IACnF,uBAAuB,EAAE,cAAc,gBAAgB,EAAE,uBAAuB,CAAC;IACjF,qCAAqC,EAAE,cAAc,gBAAgB,EAAE,qCAAqC,CAAC;IAC7G,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,YAAY,EAAE,cAAc,qBAAqB,EAAE,YAAY,CAAC;IAChE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,qBAAqB,EAAE,cAAc,qBAAqB,EAAE,qBAAqB,CAAC;IAClF,gCAAgC,EAAE,cAAc,gBAAgB,EAAE,gCAAgC,CAAC;IACnG,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,YAAY,EAAE,cAAc,oBAAoB,EAAE,YAAY,CAAC;IAC/D,cAAc,EAAE,cAAc,oBAAoB,EAAE,cAAc,CAAC;IACnE,WAAW,EAAE,cAAc,mBAAmB,EAAE,WAAW,CAAC;IAC5D,aAAa,EAAE,cAAc,mBAAmB,EAAE,aAAa,CAAC;IAChE,oBAAoB,EAAE,cAAc,8BAA8B,EAAE,oBAAoB,CAAC;IACzF,wBAAwB,EAAE,cAAc,kCAAkC,EAAE,wBAAwB,CAAC;IACrG,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,0BAA0B,EAAE,cAAc,oCAAoC,EAAE,0BAA0B,CAAC;IAC3G,2BAA2B,EAAE,cAAc,qCAAqC,EAAE,2BAA2B,CAAC;IAC9G,gBAAgB,EAAE,cAAc,yBAAyB,EAAE,gBAAgB,CAAC;IAC5E,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;IACtF,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;CACtF,CAAC"}
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/type.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,OAAO,EAAE,cAAc,gBAAgB,EAAE,OAAO,CAAC;IACjD,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,YAAY,EAAE,cAAc,gBAAgB,EAAE,YAAY,CAAC;IAC3D,WAAW,EAAE,cAAc,gBAAgB,EAAE,WAAW,CAAC;IACzD,wBAAwB,EAAE,cAAc,gBAAgB,EAAE,wBAAwB,CAAC;IACnF,uBAAuB,EAAE,cAAc,gBAAgB,EAAE,uBAAuB,CAAC;IACjF,qCAAqC,EAAE,cAAc,gBAAgB,EAAE,qCAAqC,CAAC;IAC7G,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,YAAY,EAAE,cAAc,qBAAqB,EAAE,YAAY,CAAC;IAChE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,qBAAqB,EAAE,cAAc,qBAAqB,EAAE,qBAAqB,CAAC;IAClF,gCAAgC,EAAE,cAAc,gBAAgB,EAAE,gCAAgC,CAAC;IACnG,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,YAAY,EAAE,cAAc,oBAAoB,EAAE,YAAY,CAAC;IAC/D,cAAc,EAAE,cAAc,oBAAoB,EAAE,cAAc,CAAC;IACnE,WAAW,EAAE,cAAc,mBAAmB,EAAE,WAAW,CAAC;IAC5D,aAAa,EAAE,cAAc,mBAAmB,EAAE,aAAa,CAAC;IAChE,oBAAoB,EAAE,cAAc,8BAA8B,EAAE,oBAAoB,CAAC;IACzF,wBAAwB,EAAE,cAAc,kCAAkC,EAAE,wBAAwB,CAAC;IACrG,6BAA6B,EAAE,cAAc,wCAAwC,EAAE,6BAA6B,CAAC;IACrH,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,0BAA0B,EAAE,cAAc,oCAAoC,EAAE,0BAA0B,CAAC;IAC3G,2BAA2B,EAAE,cAAc,qCAAqC,EAAE,2BAA2B,CAAC;IAC9G,gBAAgB,EAAE,cAAc,yBAAyB,EAAE,gBAAgB,CAAC;IAC5E,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;IACtF,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;CACtF,CAAC"}

package/dist/compiler/server/middleware.js

@@ -68,7 +68,7 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     else if (!runtime.serverAsyncLocalStorage) {
         runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
     }
-    const locale = runtime.extractLocaleFromRequest(request);
+    const locale = await runtime.extractLocaleFromRequestAsync(request);
     const origin = new URL(request.url).origin;
     // if the client makes a request to a URL that doesn't match
     // the localizedUrl, redirect the client to the localized URL

package/dist/compiler/server/middleware.test.js

@@ -579,3 +579,193 @@ test("does not catch errors thrown by downstream resolve call", async () => {
         throw new Error("Downstream error");
     })).rejects.toThrow();
 });
+test("middleware supports async custom server strategies", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-database", "baseLocale"],
+    });
+    // Mock an async custom strategy that simulates a database call
+    let databaseCallCount = 0;
+    runtime.defineCustomServerStrategy("custom-database", {
+        getLocale: async (request) => {
+            databaseCallCount++;
+            // Simulate async database call delay
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            // Extract user ID from a custom header (simulating authentication)
+            if (!request)
+                return undefined;
+            const userId = request.headers.get("X-User-ID");
+            if (userId === "user123") {
+                return "fr";
+            }
+            if (userId === "user456") {
+                return "de";
+            }
+            return undefined; // No user preference found
+        },
+    });
+    // Test 1: Request with user preference
+    const requestWithUserPref = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "user123",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    let middlewareResolveWasCalled = false;
+    await runtime.paraglideMiddleware(requestWithUserPref, (args) => {
+        middlewareResolveWasCalled = true;
+        expect(args.locale).toBe("fr"); // Should get locale from async custom strategy
+        return new Response("User preference locale");
+    });
+    expect(middlewareResolveWasCalled).toBe(true);
+    expect(databaseCallCount).toBe(1);
+    // Test 2: Request with different user preference
+    const requestWithOtherUser = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "user456",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    await runtime.paraglideMiddleware(requestWithOtherUser, (args) => {
+        expect(args.locale).toBe("de"); // Should get different locale
+        return new Response("Other user preference");
+    });
+    expect(databaseCallCount).toBe(2);
+});
+test("middleware falls back to other strategies when async custom strategy returns undefined", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-database", "cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+    });
+    // Mock async custom strategy that returns undefined for unknown users
+    runtime.defineCustomServerStrategy("custom-database", {
+        getLocale: async (request) => {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            if (!request)
+                return undefined;
+            const userId = request.headers.get("X-User-ID");
+            // Only return locale for known users
+            if (userId === "known-user") {
+                return "fr";
+            }
+            return undefined; // Unknown user, fallback to other strategies
+        },
+    });
+    // Request from unknown user with cookie fallback
+    const request = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "unknown-user",
+            cookie: "PARAGLIDE_LOCALE=de",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    let middlewareResolveWasCalled = false;
+    await runtime.paraglideMiddleware(request, (args) => {
+        middlewareResolveWasCalled = true;
+        expect(args.locale).toBe("de"); // Should fallback to cookie strategy
+        return new Response("Fallback locale");
+    });
+    expect(middlewareResolveWasCalled).toBe(true);
+});
+test("middleware handles async custom strategy errors gracefully", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["custom-database", "baseLocale"],
+    });
+    // Mock async custom strategy that throws an error
+    runtime.defineCustomServerStrategy("custom-database", {
+        getLocale: async () => {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            throw new Error("Database connection failed");
+        },
+    });
+    const request = new Request("https://example.com/page", {
+        headers: { "Sec-Fetch-Dest": "document" },
+    });
+    // The middleware should handle the error and not crash
+    await expect(runtime.paraglideMiddleware(request, (args) => {
+        // If we reach here, the error was handled and fallback worked
+        expect(args.locale).toBe("en"); // Should fallback to baseLocale
+        return new Response("Error handled");
+    })).rejects.toThrow("Database connection failed");
+});
+test("middleware works with multiple async custom strategies", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de", "es"],
+            },
+        }),
+        strategy: ["custom-userPref", "custom-region", "baseLocale"],
+    });
+    let userPrefCallCount = 0;
+    let regionCallCount = 0;
+    // First strategy: user preference
+    runtime.defineCustomServerStrategy("custom-userPref", {
+        getLocale: async (request) => {
+            userPrefCallCount++;
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            if (!request)
+                return undefined;
+            const userId = request.headers.get("X-User-ID");
+            return userId === "premium-user" ? "fr" : undefined;
+        },
+    });
+    // Second strategy: region detection
+    runtime.defineCustomServerStrategy("custom-region", {
+        getLocale: async (request) => {
+            regionCallCount++;
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            if (!request)
+                return undefined;
+            const region = request.headers.get("X-Region");
+            return region === "europe" ? "de" : undefined;
+        },
+    });
+    // Test 1: First strategy succeeds
+    const premiumUserRequest = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "premium-user",
+            "X-Region": "europe",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    await runtime.paraglideMiddleware(premiumUserRequest, (args) => {
+        expect(args.locale).toBe("fr"); // Should use first strategy result
+        return new Response("Premium user");
+    });
+    expect(userPrefCallCount).toBe(1);
+    // Second strategy should not be called since first one succeeded
+    expect(regionCallCount).toBe(0);
+    // Test 2: First strategy fails, second succeeds
+    const regionalUserRequest = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "regular-user",
+            "X-Region": "europe",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    await runtime.paraglideMiddleware(regionalUserRequest, (args) => {
+        expect(args.locale).toBe("de"); // Should use second strategy result
+        return new Response("Regional user");
+    });
+    expect(userPrefCallCount).toBe(2);
+    expect(regionCallCount).toBe(1);
+});

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.1.0",
+    PARJS_PACKAGE_VERSION: "2.2.0",
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -31,8 +31,8 @@
     "json5": "2.2.3",
     "unplugin": "^2.1.2",
     "urlpattern-polyfill": "^10.0.0",
-    "@inlang/sdk": "2.4.9",
-    "@inlang/recommend-sherlock": "0.2.1"
+    "@inlang/recommend-sherlock": "0.2.1",
+    "@inlang/sdk": "2.4.9"
   },
   "devDependencies": {
     "@eslint/js": "^9.18.0",
@@ -44,14 +44,14 @@
     "memfs": "4.17.0",
     "prettier": "^3.4.2",
     "rolldown": "1.0.0-beta.1",
-    "typedoc": "0.28.3",
-    "typedoc-plugin-markdown": "^4.6.0",
+    "typedoc": "^0.28.5",
+    "typedoc-plugin-markdown": "^4.7.0",
     "typedoc-plugin-missing-exports": "4.0.0",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.20.0",
     "vitest": "2.1.8",
-    "@inlang/paraglide-js": "2.1.0",
     "@inlang/plugin-message-format": "4.0.0",
+    "@inlang/paraglide-js": "2.2.0",
     "@opral/tsconfig": "1.1.0"
   },
   "keywords": [