@inlang/paraglide-js 2.0.12 → 2.1.0

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

@@ -1,6 +1,16 @@
 import { assertIsLocale } from "./assert-is-locale.js";
 import { isLocale } from "./is-locale.js";
 import { baseLocale, TREE_SHAKE_DEFAULT_URL_PATTERN_USED, urlPatterns, } from "./variables.js";
+/**
+ * If extractLocaleFromUrl is called many times on the same page and the URL
+ * hasn't changed, we don't need to recompute it every time which can get expensive.
+ * We might use a LRU cache if needed, but for now storing only the last result is enough.
+ * https://github.com/opral/monorepo/pull/3575#discussion_r2066731243
+ */
+/** @type {string|undefined} */
+let cachedUrl;
+/** @type {Locale|undefined} */
+let cachedLocale;
 /**
  * Extracts the locale from a given URL using native URLPattern.
  *
@@ -8,24 +18,36 @@ import { baseLocale, TREE_SHAKE_DEFAULT_URL_PATTERN_USED, urlPatterns, } from ".
  * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
  */
 export function extractLocaleFromUrl(url) {
+    const urlString = typeof url === "string" ? url : url.href;
+    if (cachedUrl === urlString) {
+        return cachedLocale;
+    }
+    let result;
     if (TREE_SHAKE_DEFAULT_URL_PATTERN_USED) {
-        return defaultUrlPatternExtractLocale(url);
+        result = defaultUrlPatternExtractLocale(url);
     }
-    const urlObj = typeof url === "string" ? new URL(url) : url;
-    // Iterate over URL patterns
-    for (const element of urlPatterns) {
-        for (const [locale, localizedPattern] of element.localized) {
-            const match = new URLPattern(localizedPattern, urlObj.href).exec(urlObj.href);
-            if (!match) {
-                continue;
-            }
-            // Check if the locale is valid
-            if (assertIsLocale(locale)) {
-                return locale;
+    else {
+        const urlObj = typeof url === "string" ? new URL(url) : url;
+        // Iterate over URL patterns
+        for (const element of urlPatterns) {
+            for (const [locale, localizedPattern] of element.localized) {
+                const match = new URLPattern(localizedPattern, urlObj.href).exec(urlObj.href);
+                if (!match) {
+                    continue;
+                }
+                // Check if the locale is valid
+                if (assertIsLocale(locale)) {
+                    result = locale;
+                    break;
+                }
             }
+            if (result)
+                break;
         }
     }
-    return undefined;
+    cachedUrl = urlString;
+    cachedLocale = result;
+    return result;
 }
 /**
  * https://github.com/opral/inlang-paraglide-js/issues/381

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,CAiEpB;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,17 @@ 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);
+            locale = handler.getLocale();
+        }
         // check if match, else continue loop
         if (locale !== undefined) {
             const asserted = assertIsLocale(locale);
@@ -80,29 +85,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

@@ -183,3 +183,156 @@ test("initially sets the locale after resolving it for the first time", async ()
     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");
 });
+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/localize-href.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localize-href.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-href.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,mCALW,MAAM,YAEd;IAAyB,MAAM;CAC/B,GAAU,MAAM,CAsBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qCAJW,MAAM,GACJ,MAAM,CAelB"}
+{"version":3,"file":"localize-href.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-href.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,mCALW,MAAM,YAEd;IAAyB,MAAM;CAC/B,GAAU,MAAM,CAyBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qCAJW,MAAM,GACJ,MAAM,CAelB"}

package/dist/compiler/runtime/localize-href.js

@@ -40,15 +40,18 @@ import { deLocalizeUrl, localizeUrl } from "./localize-url.js";
  * @returns {string} The localized href, relative if input was relative
  */
 export function localizeHref(href, options) {
-    const locale = options?.locale ?? getLocale();
+    const currentLocale = getLocale();
+    const locale = options?.locale ?? currentLocale;
     const url = new URL(href, getUrlOrigin());
-    const localized = localizeUrl(url, options);
+    const localized = localizeUrl(url, { locale });
     // if the origin is identical and the href is relative,
     // return the relative path
     if (href.startsWith("/") && url.origin === localized.origin) {
         // check for cross origin localization in which case an absolute URL must be returned.
-        if (locale !== getLocale()) {
-            const localizedCurrentLocale = localizeUrl(url, { locale: getLocale() });
+        if (locale !== currentLocale) {
+            const localizedCurrentLocale = localizeUrl(url, {
+                locale: currentLocale,
+            });
             if (localizedCurrentLocale.origin !== localized.origin) {
                 return localized.href;
             }

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,CAqFnE;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.
  *
@@ -75,6 +76,10 @@ export let setLocale = (newLocale, options) => {
             // set the localStorage
             localStorage.setItem(localStorageKey, newLocale);
         }
+        else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
+            const handler = customClientStrategies.get(strat);
+            handler.setLocale(newLocale);
+        }
     }
     if (!isServer &&
         optionsWithDefaults.reload &&

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

@@ -251,3 +251,143 @@ test("should set locale in all configured storage mechanisms regardless of which
     expect(globalThis.localStorage.setItem).toHaveBeenCalledWith("PARAGLIDE_LOCALE", "fr");
     expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=fr; path=/; max-age=34560000; domain=example.com");
 });
+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; domain=example.com");
+});
+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");
+});

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

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ * @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 {CustomServerStrategyHandler} handler The handler for the custom strategy, which should implement
+ * 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 {CustomClientStrategyHandler} handler The handler for the custom strategy, which should implement the
+ * methods `getLocale` and `setLocale`.
+ * @returns {void}
+ */
+export function defineCustomClientStrategy(strategy: any, handler: CustomClientStrategyHandler): void;
+/**
+ * @typedef {"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage"} BuiltInStrategy
+ */
+/**
+ * @typedef {`custom_${string}`} CustomStrategy
+ */
+/**
+ * @typedef {BuiltInStrategy | CustomStrategy} Strategy
+ */
+/**
+ * @typedef {Array<Strategy>} Strategies
+ */
+/**
+ * @typedef {{ getLocale: (request?: Request) => string | undefined }} CustomServerStrategyHandler
+ */
+/**
+ * @typedef {{ getLocale: () => string | undefined, setLocale: (locale: string) => void }} CustomClientStrategyHandler
+ */
+export const customServerStrategies: Map<any, any>;
+export const customClientStrategies: Map<any, any>;
+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;
+};
+export type CustomClientStrategyHandler = {
+    getLocale: () => string | undefined;
+    setLocale: (locale: string) => void;
+};
+//# sourceMappingURL=strategy.d.ts.map

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

@@ -0,0 +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"}

package/dist/compiler/runtime/strategy.js

@@ -0,0 +1,62 @@
+/**
+ * @typedef {"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage"} BuiltInStrategy
+ */
+/**
+ * @typedef {`custom_${string}`} CustomStrategy
+ */
+/**
+ * @typedef {BuiltInStrategy | CustomStrategy} Strategy
+ */
+/**
+ * @typedef {Array<Strategy>} Strategies
+ */
+/**
+ * @typedef {{ getLocale: (request?: Request) => string | undefined }} CustomServerStrategyHandler
+ */
+/**
+ * @typedef {{ getLocale: () => string | undefined, setLocale: (locale: string) => void }} CustomClientStrategyHandler
+ */
+export const customServerStrategies = new Map();
+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.
+ * @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);
+}
+/**
+ * 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 {CustomServerStrategyHandler} handler The handler for the custom strategy, which should implement
+ * 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.");
+    }
+    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 {CustomClientStrategyHandler} handler The handler for the custom strategy, which should implement the
+ * 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.");
+    }
+    customClientStrategies.set(strategy, handler);
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=strategy.test.d.ts.map

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

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