@inlang/paraglide-js 2.0.13 → 2.2.0

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

@@ -1,7 +1,9 @@
 import { assertIsLocale } from "./assert-is-locale.js";
-import { baseLocale, cookieName, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED, TREE_SHAKE_URL_STRATEGY_USED, } from "./variables.js";
+import { extractLocaleFromHeader } from "./extract-locale-from-header.js";
 import { extractLocaleFromUrl } from "./extract-locale-from-url.js";
 import { isLocale } from "./is-locale.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.
  *
@@ -12,6 +14,9 @@ import { isLocale } from "./is-locale.js";
  * 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);
  *
@@ -33,10 +38,7 @@ export const extractLocaleFromRequest = (request) => {
         }
         else if (TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED &&
             strat === "preferredLanguage") {
-            const acceptLanguageHeader = request.headers.get("accept-language");
-            if (acceptLanguageHeader) {
-                locale = negotiatePreferredLanguageFromHeader(acceptLanguageHeader);
-            }
+            locale = extractLocaleFromHeader(request);
         }
         else if (strat === "globalVariable") {
             locale = _locale;
@@ -47,6 +49,11 @@ export const extractLocaleFromRequest = (request) => {
         else if (strat === "localStorage") {
             continue;
         }
+        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)) {
                 locale = undefined;
@@ -58,34 +65,3 @@ export const extractLocaleFromRequest = (request) => {
     }
     throw new Error("No locale found. There is an error in your strategy. Try adding 'baseLocale' as the very last strategy. Read more here https://inlang.com/m/gerre34r/library-inlang-paraglideJs/errors#no-locale-found");
 };
-/**
- * Negotiates a preferred language from a header.
- *
- * @param {string} header - The header to negotiate from.
- * @returns {string|undefined} The negotiated preferred language.
- */
-function negotiatePreferredLanguageFromHeader(header) {
-    // Parse language preferences with their q-values and base language codes
-    const languages = header
-        .split(",")
-        .map((lang) => {
-        const [tag, q = "1"] = lang.trim().split(";q=");
-        // Get both the full tag and base language code
-        const baseTag = tag?.split("-")[0]?.toLowerCase();
-        return {
-            fullTag: tag?.toLowerCase(),
-            baseTag,
-            q: Number(q),
-        };
-    })
-        .sort((a, b) => b.q - a.q);
-    for (const lang of languages) {
-        if (isLocale(lang.fullTag)) {
-            return lang.fullTag;
-        }
-        else if (isLocale(lang.baseTag)) {
-            return lang.baseTag;
-        }
-    }
-    return undefined;
-}

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

@@ -1,6 +1,6 @@
-import { test, expect } from "vitest";
-import { createParaglide } from "../create-paraglide.js";
 import { newProject } from "@inlang/sdk";
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
 test("returns the locale from the cookie", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
@@ -238,3 +238,85 @@ test("preferredLanguage precedence over url", async () => {
     const locale = runtime.extractLocaleFromRequest(request);
     expect(locale).toBe("de");
 });
+test("sync version no longer supports custom strategies", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-header", "baseLocale"],
+    });
+    // Define a custom strategy that extracts locale from a custom header
+    runtime.defineCustomServerStrategy("custom-header", {
+        getLocale: (request) => request?.headers.get("X-Custom-Locale") ?? undefined,
+    });
+    const request = new Request("http://example.com", {
+        headers: {
+            "X-Custom-Locale": "fr",
+        },
+    });
+    // Sync version skips custom strategies and falls back to baseLocale
+    const locale = runtime.extractLocaleFromRequest(request);
+    expect(locale).toBe("en"); // baseLocale fallback
+});
+test("sync version skips custom strategy and falls back to next built-in strategy", 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 = runtime.extractLocaleFromRequest(request);
+    expect(locale).toBe("en"); // Should fall back to baseLocale (skipping custom strategy)
+});
+test("sync version uses built-in strategies instead of custom strategies", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-priority", "cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+    });
+    runtime.defineCustomServerStrategy("custom-priority", {
+        getLocale: () => "de",
+    });
+    const request = new Request("http://example.com", {
+        headers: {
+            cookie: "PARAGLIDE_LOCALE=fr", // Cookie has different locale
+        },
+    });
+    const locale = runtime.extractLocaleFromRequest(request);
+    expect(locale).toBe("fr"); // Should use cookie since custom strategy is skipped in sync version
+});
+test("sync version skips all custom strategies and uses baseLocale", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-first", "custom-second", "baseLocale"],
+    });
+    runtime.defineCustomServerStrategy("custom-first", {
+        getLocale: () => undefined,
+    });
+    runtime.defineCustomServerStrategy("custom-second", {
+        getLocale: () => "fr",
+    });
+    const request = new Request("http://example.com");
+    const locale = runtime.extractLocaleFromRequest(request);
+    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":"AA+BA;;;;;;;;;;;GAWG;AACH,sBAFU,MAAM,MAAM,CA8DpB;AA4BF;;;;;;;;;;;;;;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

@@ -1,9 +1,10 @@
 import { assertIsLocale } from "./assert-is-locale.js";
-import { isLocale } from "./is-locale.js";
-import { baseLocale, strategy, serverAsyncLocalStorage, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED, TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED, TREE_SHAKE_URL_STRATEGY_USED, TREE_SHAKE_LOCAL_STORAGE_STRATEGY_USED, localStorageKey, isServer, } from "./variables.js";
 import { extractLocaleFromCookie } from "./extract-locale-from-cookie.js";
+import { extractLocaleFromNavigator } from "./extract-locale-from-navigator.js";
 import { extractLocaleFromUrl } from "./extract-locale-from-url.js";
 import { setLocale } from "./set-locale.js";
+import { customClientStrategies, isCustomStrategy } from "./strategy.js";
+import { baseLocale, isServer, localStorageKey, serverAsyncLocalStorage, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED, TREE_SHAKE_LOCAL_STORAGE_STRATEGY_USED, TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED, TREE_SHAKE_URL_STRATEGY_USED, } from "./variables.js";
 /**
  * This is a fallback to get started with a custom
  * strategy and avoid type errors.
@@ -59,13 +60,25 @@ export let getLocale = () => {
         else if (TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED &&
             strat === "preferredLanguage" &&
             !isServer) {
-            locale = negotiatePreferredLanguageFromNavigator();
+            locale = extractLocaleFromNavigator();
         }
         else if (TREE_SHAKE_LOCAL_STORAGE_STRATEGY_USED &&
             strat === "localStorage" &&
             !isServer) {
             locale = localStorage.getItem(localStorageKey) ?? undefined;
         }
+        else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
+            const handler = customClientStrategies.get(strat);
+            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) {
             const asserted = assertIsLocale(locale);
@@ -80,29 +93,6 @@ export let getLocale = () => {
     }
     throw new Error("No locale found. Read the docs https://inlang.com/m/gerre34r/library-inlang-paraglideJs/errors#no-locale-found");
 };
-/**
- * Negotiates a preferred language from navigator.languages.
- *
- * @returns {string|undefined} The negotiated preferred language.
- */
-function negotiatePreferredLanguageFromNavigator() {
-    if (!navigator?.languages?.length) {
-        return undefined;
-    }
-    const languages = navigator.languages.map((lang) => ({
-        fullTag: lang.toLowerCase(),
-        baseTag: lang.split("-")[0]?.toLowerCase(),
-    }));
-    for (const lang of languages) {
-        if (isLocale(lang.fullTag)) {
-            return lang.fullTag;
-        }
-        else if (isLocale(lang.baseTag)) {
-            return lang.baseTag;
-        }
-    }
-    return undefined;
-}
 /**
  * Overwrite the \`getLocale()\` function.
  *

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

@@ -180,6 +180,159 @@ 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 () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-client", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-client", {
+        getLocale: () => "fr",
+        setLocale: () => { },
+    });
+    const locale = runtime.getLocale();
+    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-undefined", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-undefined", {
+        getLocale: () => undefined,
+        setLocale: () => { },
+    });
+    const locale = runtime.getLocale();
+    expect(locale).toBe("en"); // Should fall back to baseLocale
+});
+test("throws error if custom strategy returns invalid locale", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["custom-invalid", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-invalid", {
+        getLocale: () => "invalid-locale",
+        setLocale: () => { },
+    });
+    expect(() => runtime.getLocale()).toThrow();
+});
+test("custom strategy takes precedence over built-in strategies in getLocale", async () => {
+    // @ts-expect-error - global variable definition
+    globalThis.document = { cookie: "PARAGLIDE_LOCALE=fr" };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-priority", "cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-priority", {
+        getLocale: () => "de",
+        setLocale: () => { },
+    });
+    const locale = runtime.getLocale();
+    expect(locale).toBe("de"); // Should use custom strategy, not cookie
+});
+test("multiple custom strategies work in order in getLocale", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-first", "custom-second", "baseLocale"],
+        isServer: "false",
+    });
+    // Define two custom strategies
+    runtime.defineCustomClientStrategy("custom-first", {
+        getLocale: () => undefined, // This one returns undefined
+        setLocale: () => { },
+    });
+    runtime.defineCustomClientStrategy("custom-second", {
+        getLocale: () => "fr", // This one returns a locale
+        setLocale: () => { },
+    });
+    const locale = runtime.getLocale();
+    expect(locale).toBe("fr"); // Should use second custom strategy
+});
+test("custom strategy works with session storage simulation", async () => {
+    // Simulate a custom strategy that reads from session storage
+    let sessionData = "de";
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-session", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-session", {
+        getLocale: () => sessionData,
+        setLocale: (locale) => {
+            sessionData = locale;
+        },
+    });
+    const locale = runtime.getLocale();
+    expect(locale).toBe("de");
+});
+test("custom strategy integrates with locale initialization", async () => {
+    // @ts-expect-error - global variable definition
+    globalThis.window = {};
+    // Define a custom strategy that tracks if it was called
+    let getLocaleCalled = false;
+    let setLocaleCalled = false;
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-tracking"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-tracking", {
+        getLocale: () => {
+            getLocaleCalled = true;
+            return "fr";
+        },
+        setLocale: () => {
+            setLocaleCalled = true;
+        },
+    });
+    // First call should trigger the custom strategy
+    const locale = runtime.getLocale();
+    expect(locale).toBe("fr");
+    expect(getLocaleCalled).toBe(true);
+    // Setting the locale should also call the custom strategy
+    runtime.setLocale("de");
+    // The locale should be set internally after first resolution
+    expect(setLocaleCalled).toBe(true);
+});

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":"AAeA;;;;;;;;;;;;;;;GAeG;AACH,sBAFU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,IAAI,CAkFnE;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

@@ -1,6 +1,7 @@
 import { getLocale } from "./get-locale.js";
 import { localizeUrl } from "./localize-url.js";
-import { cookieMaxAge, cookieName, cookieDomain, isServer, localStorageKey, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED, TREE_SHAKE_LOCAL_STORAGE_STRATEGY_USED, TREE_SHAKE_URL_STRATEGY_USED, } from "./variables.js";
+import { customClientStrategies, isCustomStrategy } from "./strategy.js";
+import { cookieDomain, cookieMaxAge, cookieName, isServer, localStorageKey, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED, TREE_SHAKE_LOCAL_STORAGE_STRATEGY_USED, TREE_SHAKE_URL_STRATEGY_USED, } from "./variables.js";
 /**
  * Set the locale.
  *
@@ -46,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
@@ -75,6 +78,18 @@ export let setLocale = (newLocale, options) => {
             // set the localStorage
             localStorage.setItem(localStorageKey, newLocale);
         }
+        else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
+            const handler = customClientStrategies.get(strat);
+            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 &&
         optionsWithDefaults.reload &&

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,5 +249,145 @@ 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";
+    let setLocaleCalled = false;
+    globalThis.window = {
+        location: { reload: vi.fn() },
+    };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-setter", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-setter", {
+        getLocale: () => customLocale,
+        setLocale: (locale) => {
+            customLocale = locale;
+            setLocaleCalled = true;
+        },
+    });
+    runtime.setLocale("fr");
+    expect(setLocaleCalled).toBe(true);
+    expect(customLocale).toBe("fr");
+    expect(globalThis.window.location.reload).toHaveBeenCalled();
+});
+test("calls setLocale on multiple custom strategies", async () => {
+    let customLocale1 = "en";
+    let customLocale2 = "en";
+    let setLocaleCalled1 = false;
+    let setLocaleCalled2 = false;
+    globalThis.window = {
+        location: { reload: vi.fn() },
+    };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-multi1", "custom-multi2", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-multi1", {
+        getLocale: () => customLocale1,
+        setLocale: (locale) => {
+            customLocale1 = locale;
+            setLocaleCalled1 = true;
+        },
+    });
+    runtime.defineCustomClientStrategy("custom-multi2", {
+        getLocale: () => customLocale2,
+        setLocale: (locale) => {
+            customLocale2 = locale;
+            setLocaleCalled2 = true;
+        },
+    });
+    runtime.setLocale("de");
+    expect(setLocaleCalled1).toBe(true);
+    expect(setLocaleCalled2).toBe(true);
+    expect(customLocale1).toBe("de");
+    expect(customLocale2).toBe("de");
+});
+test("custom strategy setLocale works with cookie and localStorage", async () => {
+    let customData = "en";
+    globalThis.document = { cookie: "" };
+    globalThis.localStorage = {
+        setItem: vi.fn(),
+        getItem: () => null,
+    };
+    globalThis.window = {
+        location: {
+            hostname: "example.com",
+            reload: vi.fn(),
+        },
+    };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-api", "localStorage", "cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-api", {
+        getLocale: () => customData,
+        setLocale: (locale) => {
+            customData = locale;
+        },
+    });
+    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");
+});
+test("custom strategy setLocale integrates with URL strategy", async () => {
+    let customStoredLocale = "en";
+    globalThis.window = {
+        location: {
+            hostname: "example.com",
+            href: "https://example.com/en/page",
+            reload: vi.fn(),
+        },
+    };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["url", "custom-urlIntegration", "baseLocale"],
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:locale/:path*",
+                localized: [
+                    ["en", "https://example.com/en/:path*"],
+                    ["fr", "https://example.com/fr/:path*"],
+                    ["de", "https://example.com/de/:path*"],
+                ],
+            },
+        ],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-urlIntegration", {
+        getLocale: () => customStoredLocale,
+        setLocale: (locale) => {
+            customStoredLocale = locale;
+        },
+    });
+    runtime.setLocale("de");
+    expect(globalThis.window.location.href).toBe("https://example.com/de/page");
+    expect(customStoredLocale).toBe("de");
 });