@turnipxenon/pineapple 4.5.1 → 5.0.0-alpha.1

package/dist/external/paraglide/runtime.js

@@ -1,4 +1,4 @@
-// eslint-disable
+/* eslint-disable */
 
 /** @type {any} */
 const URLPattern = {}
@@ -26,9 +26,11 @@ export const cookieName = "PARAGLIDE_LOCALE";
 /** @type {number} */
 export const cookieMaxAge = 34560000;
 /** @type {string} */
+export const cookieDomain = "";
+/** @type {string} */
 export const localStorageKey = "PARAGLIDE_LOCALE";
 /**
- * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage">}
+ * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>}
  */
 export const strategy = [
   "url",
@@ -159,13 +161,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);
@@ -180,29 +194,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.
  *
@@ -222,6 +213,25 @@ export const overwriteGetLocale = (fn) => {
     getLocale = fn;
 };
 
+/**
+ * Navigates to the localized URL, or reloads the current page
+ *
+ * @param {string} [newLocation] The new location
+ * @return {undefined}
+ */
+const navigateOrReload = (newLocation) => {
+    if (newLocation) {
+        // reload the page by navigating to the new url
+        window.location.href = newLocation;
+    }
+    else {
+        // reload the page to reflect the new locale
+        window.location.reload();
+    }
+};
+/**
+ * @typedef {(newLocale: Locale, options?: { reload?: boolean }) => void | Promise<void>} SetLocaleFn
+ */
 /**
  * Set the locale.
  *
@@ -230,13 +240,16 @@ export const overwriteGetLocale = (fn) => {
  * reloading is disabled, you need to ensure that the UI is updated
  * to reflect the new locale.
  *
+ * If any custom strategy's \`setLocale\` function is async, then this
+ * function will become async as well.
+ *
  * @example
  *   setLocale('en');
  *
  * @example
  *   setLocale('en', { reload: false });
  *
- * @type {(newLocale: Locale, options?: { reload?: boolean }) => void}
+ * @type {SetLocaleFn}
  */
 export let setLocale = (newLocale, options) => {
     const optionsWithDefaults = {
@@ -245,6 +258,7 @@ export let setLocale = (newLocale, options) => {
     };
     // locale is already set
     // https://github.com/opral/inlang-paraglide-js/issues/430
+    /** @type {Locale | undefined} */
     let currentLocale;
     try {
         currentLocale = getLocale();
@@ -252,6 +266,8 @@ export let setLocale = (newLocale, options) => {
     catch {
         // do nothing, no locale has been set yet.
     }
+    /** @type {Array<Promise<any>>} */
+    const customSetLocalePromises = [];
     /** @type {string | undefined} */
     let newLocation = undefined;
     for (const strat of strategy) {
@@ -262,11 +278,16 @@ export let setLocale = (newLocale, options) => {
             _locale = newLocale;
         }
         else if (TREE_SHAKE_COOKIE_STRATEGY_USED && strat === "cookie") {
-            if (isServer || typeof document === "undefined") {
+            if (isServer ||
+                typeof document === "undefined" ||
+                typeof window === "undefined") {
                 continue;
             }
             // set the cookie
-            document.cookie = `${cookieName}=${newLocale}; path=/; max-age=${cookieMaxAge}`;
+            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
@@ -293,20 +314,36 @@ export let setLocale = (newLocale, options) => {
             // set the localStorage
             localStorage.setItem(localStorageKey, newLocale);
         }
-    }
-    if (!isServer &&
-        optionsWithDefaults.reload &&
-        window.location &&
-        newLocale !== currentLocale) {
-        if (newLocation) {
-            // reload the page by navigating to the new url
-            window.location.href = newLocation;
+        else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
+            const handler = customClientStrategies.get(strat);
+            if (handler) {
+                let result = handler.setLocale(newLocale);
+                // Handle async setLocale
+                if (result instanceof Promise) {
+                    result = result.catch((error) => {
+                        throw new Error(`Custom strategy "${strat}" setLocale failed.`, {
+                            cause: error,
+                        });
+                    });
+                    customSetLocalePromises.push(result);
+                }
+            }
         }
-        else {
-            // reload the page to reflect the new locale
-            window.location.reload();
+    }
+    const runReload = () => {
+        if (!isServer &&
+            optionsWithDefaults.reload &&
+            window.location &&
+            newLocale !== currentLocale) {
+            navigateOrReload(newLocation);
         }
+    };
+    if (customSetLocalePromises.length) {
+        return Promise.all(customSetLocalePromises).then(() => {
+            runReload();
+        });
     }
+    runReload();
     return;
 };
 /**
@@ -321,10 +358,10 @@ export let setLocale = (newLocale, options) => {
  *     return Cookies.set('locale', newLocale)
  *   });
  *
- * @param {(newLocale: Locale) => void} fn
+ * @param {SetLocaleFn} fn
  */
 export const overwriteSetLocale = (fn) => {
-    setLocale = fn;
+    setLocale = /** @type {SetLocaleFn} */ (fn);
 };
 
 /**
@@ -398,6 +435,9 @@ export function assertIsLocale(input) {
  * 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);
  *
@@ -419,10 +459,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;
@@ -433,6 +470,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;
@@ -444,42 +486,62 @@ 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.
+ * Asynchronously extracts a locale from a request.
  *
- * @param {string} header - The header to negotiate from.
- * @returns {string|undefined} The negotiated preferred language.
+ * 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>}
  */
-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;
+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);
+            }
         }
     }
-    return undefined;
-}
+    // If no custom strategy provided a valid locale, fall back to sync version
+    locale = extractLocaleFromRequest(request);
+    return assertIsLocale(locale);
+};
 
 /**
  * Extracts a cookie from the document.
  *
- * Will return undefined if the docuement is not available or if the cookie is not set.
+ * Will return undefined if the document is not available or if the cookie is not set.
  * The `document` object is not available in server-side rendering, so this function should not be called in that context.
  *
  * @returns {string | undefined}
@@ -496,6 +558,90 @@ export function extractLocaleFromCookie() {
     return undefined;
 }
 
+/**
+ * Extracts a locale from the accept-language header.
+ *
+ * Use the function on the server to extract the locale
+ * from the accept-language header that is sent by the client.
+ *
+ * @example
+ *   const locale = extractLocaleFromHeader(request);
+ *
+ * @type {(request: Request) => Locale}
+ * @param {Request} request - The request object to extract the locale from.
+ * @returns {string|undefined} The negotiated preferred language.
+ */
+export function extractLocaleFromHeader(request) {
+    const acceptLanguageHeader = request.headers.get("accept-language");
+    if (acceptLanguageHeader) {
+        // Parse language preferences with their q-values and base language codes
+        const languages = acceptLanguageHeader
+            .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;
+    }
+    return undefined;
+}
+
+/**
+ * Negotiates a preferred language from navigator.languages.
+ *
+ * Use the function on the client to extract the locale
+ * from the navigator.languages array.
+ *
+ * @example
+ *   const locale = extractLocaleFromNavigator();
+ *
+ * @type {() => Locale | undefined}
+ * @returns {string | undefined}
+ */
+export function extractLocaleFromNavigator() {
+    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;
+}
+
+/**
+ * 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.
  *
@@ -503,24 +649,36 @@ export function extractLocaleFromCookie() {
  * @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
@@ -848,6 +1006,120 @@ export function aggregateGroups(match) {
     };
 }
 
+/**
+ * @typedef {object} ShouldRedirectServerInput
+ * @property {Request} request
+ * @property {string | URL} [url]
+ * @property {ReturnType<typeof assertIsLocale>} [locale]
+ *
+ * @typedef {object} ShouldRedirectClientInput
+ * @property {undefined} [request]
+ * @property {string | URL} [url]
+ * @property {ReturnType<typeof assertIsLocale>} [locale]
+ *
+ * @typedef {ShouldRedirectServerInput | ShouldRedirectClientInput} ShouldRedirectInput
+ *
+ * @typedef {object} ShouldRedirectResult
+ * @property {boolean} shouldRedirect - Indicates whether the consumer should perform a redirect.
+ * @property {ReturnType<typeof assertIsLocale>} locale - Locale resolved using the configured strategies.
+ * @property {URL | undefined} redirectUrl - Destination URL when a redirect is required.
+ */
+/**
+ * Determines whether a redirect is required to align the current URL with the active locale.
+ *
+ * This helper mirrors the logic that powers `paraglideMiddleware`, but works in both server
+ * and client environments. It evaluates the configured strategies in order, computes the
+ * canonical localized URL, and reports when the current URL does not match.
+ *
+ * When called in the browser without arguments, the current `window.location.href` is used.
+ *
+ * @example
+ * // Client side usage (e.g. TanStack Router beforeLoad hook)
+ * async function beforeLoad({ location }) {
+ *   const decision = await shouldRedirect({ url: location.href });
+ *
+ *   if (decision.shouldRedirect) {
+ *     throw redirect({ to: decision.redirectUrl.href });
+ *   }
+ * }
+ *
+ * @example
+ * // Server side usage with a Request
+ * export async function handle(request) {
+ *   const decision = await shouldRedirect({ request });
+ *
+ *   if (decision.shouldRedirect) {
+ *     return Response.redirect(decision.redirectUrl, 307);
+ *   }
+ *
+ *   return render(request, decision.locale);
+ * }
+ *
+ * @param {ShouldRedirectInput} [input]
+ * @returns {Promise<ShouldRedirectResult>}
+ */
+export async function shouldRedirect(input = {}) {
+    const locale = /** @type {ReturnType<typeof assertIsLocale>} */ (await resolveLocale(input));
+    if (!strategy.includes("url")) {
+        return { shouldRedirect: false, locale, redirectUrl: undefined };
+    }
+    const currentUrl = resolveUrl(input);
+    const localizedUrl = localizeUrl(currentUrl.href, { locale });
+    const shouldRedirectToLocalizedUrl = normalizeUrl(localizedUrl.href) !== normalizeUrl(currentUrl.href);
+    return {
+        shouldRedirect: shouldRedirectToLocalizedUrl,
+        locale,
+        redirectUrl: shouldRedirectToLocalizedUrl ? localizedUrl : undefined,
+    };
+}
+/**
+ * Resolves the locale either from the provided input or by using the configured strategies.
+ *
+ * @param {ShouldRedirectInput} input
+ * @returns {Promise<ReturnType<typeof assertIsLocale>>}
+ */
+async function resolveLocale(input) {
+    if (input.locale) {
+        return assertIsLocale(input.locale);
+    }
+    if (input.request) {
+        return extractLocaleFromRequestAsync(input.request);
+    }
+    return getLocale();
+}
+/**
+ * Resolves the current URL from the provided input or runtime context.
+ *
+ * @param {ShouldRedirectInput} input
+ * @returns {URL}
+ */
+function resolveUrl(input) {
+    if (input.request) {
+        return new URL(input.request.url);
+    }
+    if (input.url instanceof URL) {
+        return new URL(input.url.href);
+    }
+    if (typeof input.url === "string") {
+        return new URL(input.url, getUrlOrigin());
+    }
+    if (typeof window !== "undefined" && window?.location?.href) {
+        return new URL(window.location.href);
+    }
+    throw new Error("shouldRedirect() requires either a request, an absolute URL, or must run in a browser environment.");
+}
+/**
+ * Normalize url for comparison by stripping the trailing slash.
+ *
+ * @param {string} url
+ * @returns {string}
+ */
+function normalizeUrl(url) {
+    const urlObj = new URL(url);
+    urlObj.pathname = urlObj.pathname.replace(/\/$/, "");
+    return urlObj.href;
+}
+
 /**
  * High-level URL localization function optimized for client-side UI usage.
  *
@@ -887,15 +1159,18 @@ export function aggregateGroups(match) {
  * @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;
             }
@@ -1057,6 +1332,67 @@ export function generateStaticLocalizedUrls(urls) {
     return Array.from(localizedUrls);
 }
 
+/**
+ * @typedef {"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage"} BuiltInStrategy
+ */
+/**
+ * @typedef {`custom_${string}`} CustomStrategy
+ */
+/**
+ * @typedef {BuiltInStrategy | CustomStrategy} Strategy
+ */
+/**
+ * @typedef {Array<Strategy>} Strategies
+ */
+/**
+ * @typedef {{ getLocale: (request?: Request) => Promise<string | undefined> | (string | undefined) }} CustomServerStrategyHandler
+ */
+/**
+ * @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, 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));
+}
+/**
+ * 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 with alphanumeric characters, hyphens, or underscores.
+ * @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.`);
+    }
+    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 with alphanumeric characters, hyphens, or underscores.
+ * @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.`);
+    }
+    customClientStrategies.set(strategy, handler);
+}
+
 // ------ TYPES ------
 
 /**