@inlang/paraglide-js 2.3.0 → 2.3.2

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

@@ -6,16 +6,19 @@
  * 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 {(newLocale: Locale, options?: { reload?: boolean }) => Promise<any> | void}
  */
 export let setLocale: (newLocale: Locale, options?: {
     reload?: boolean;
-}) => void;
+}) => Promise<any> | void;
 export function overwriteSetLocale(fn: (newLocale: Locale) => void): void;
 //# sourceMappingURL=set-locale.d.ts.map

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,CA8FnE;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":"AAgCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sBAFU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAuGlF;AAgBK,uCAFI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,QAIrC"}

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

@@ -2,6 +2,22 @@ import { getLocale } from "./get-locale.js";
 import { localizeUrl } from "./localize-url.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";
+/**
+ * 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();
+    }
+};
 /**
  * Set the locale.
  *
@@ -10,13 +26,16 @@ import { cookieDomain, cookieMaxAge, cookieName, isServer, localStorageKey, stra
  * 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 {(newLocale: Locale, options?: { reload?: boolean }) => Promise<any> | void}
  */
 export let setLocale = (newLocale, options) => {
     const optionsWithDefaults = {
@@ -32,6 +51,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) {
@@ -81,12 +102,15 @@ export let setLocale = (newLocale, options) => {
         else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
             const handler = customClientStrategies.get(strat);
             if (handler) {
-                const result = handler.setLocale(newLocale);
+                let 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);
+                    result = result.catch((error) => {
+                        throw new Error(`Custom strategy "${strat}" setLocale failed.`, {
+                            cause: error,
+                        });
                     });
+                    customSetLocalePromises.push(result);
                 }
             }
         }
@@ -95,15 +119,19 @@ export let setLocale = (newLocale, options) => {
         optionsWithDefaults.reload &&
         window.location &&
         newLocale !== currentLocale) {
-        if (newLocation) {
-            // reload the page by navigating to the new url
-            window.location.href = newLocation;
+        if (customSetLocalePromises.length) {
+            // Wait for any async custom setLocale functions
+            return Promise.all(customSetLocalePromises).then(() => {
+                navigateOrReload(newLocation);
+            });
         }
         else {
-            // reload the page to reflect the new locale
-            window.location.reload();
+            navigateOrReload(newLocation);
         }
     }
+    else if (customSetLocalePromises.length) {
+        return Promise.all(customSetLocalePromises);
+    }
     return;
 };
 /**

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

@@ -317,6 +317,129 @@ test("calls setLocale on multiple custom strategies", async () => {
     expect(customLocale1).toBe("de");
     expect(customLocale2).toBe("de");
 });
+test("setLocale should return a promise if any custom setLocale function is async", async () => {
+    let customLocale1 = "en";
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-async", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-async", {
+        getLocale: () => customLocale1,
+        setLocale: async (locale) => {
+            customLocale1 = locale;
+        },
+    });
+    const setLocalePromise = runtime.setLocale("de");
+    const setLocalePromiseWithoutReload = runtime.setLocale("de", {
+        reload: false,
+    });
+    expect(setLocalePromise).toBeInstanceOf(Promise);
+    expect(setLocalePromiseWithoutReload).toBeInstanceOf(Promise);
+});
+test("awaits async setLocale functions to resolve in custom strategy", async () => {
+    let customLocale1 = "en";
+    globalThis.window = {
+        location: {
+            reload: vi.fn(),
+        },
+    };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-async", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-async", {
+        getLocale: () => customLocale1,
+        setLocale: async (locale) => {
+            customLocale1 = locale;
+        },
+    });
+    const setLocalePromise = runtime.setLocale("de");
+    expect(window.location.reload).not.toHaveBeenCalled();
+    await setLocalePromise;
+    // Verify that setLocale resolved before reload was called
+    expect(window.location.reload).toHaveBeenCalledTimes(1);
+    expect(customLocale1).toBe("de");
+});
+test("awaits async setLocale functions to resolve in multiple custom strategies", async () => {
+    let customLocale1 = "en";
+    let customLocale2 = "en";
+    globalThis.window = {
+        location: {
+            reload: vi.fn(),
+        },
+    };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-async1", "custom-async2", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-async1", {
+        getLocale: () => customLocale1,
+        setLocale: async (locale) => {
+            customLocale1 = locale;
+        },
+    });
+    runtime.defineCustomClientStrategy("custom-async2", {
+        getLocale: () => customLocale2,
+        setLocale: async (locale) => {
+            customLocale2 = locale;
+        },
+    });
+    const setLocalePromise = runtime.setLocale("de");
+    expect(window.location.reload).not.toHaveBeenCalled();
+    await setLocalePromise;
+    // Verify that setLocale resolved before reload was called
+    expect(window.location.reload).toHaveBeenCalledTimes(1);
+    expect(customLocale1).toBe("de");
+    expect(customLocale2).toBe("de");
+});
+test("reload should not run if async setLocale function rejects in custom strategy", async () => {
+    const customLocale1 = "en";
+    globalThis.window = {
+        location: {
+            reload: vi.fn(),
+        },
+    };
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-async", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-async", {
+        getLocale: () => customLocale1,
+        setLocale: async () => {
+            throw new Error("fetch error");
+        },
+    });
+    const error = expect(() => runtime.setLocale("de")).rejects;
+    await error.toThrowError(`Custom strategy "custom-async" setLocale failed.`);
+    await error.toMatchObject({ cause: { message: "fetch error" } });
+    // Verify that reload was never called
+    expect(window.location.reload).toHaveBeenCalledTimes(0);
+    expect(customLocale1).toBe("en");
+});
 test("custom strategy setLocale works with cookie and localStorage", async () => {
     let customData = "en";
     globalThis.document = { cookie: "" };

package/dist/services/env-variables/index.js

@@ -1,5 +1,5 @@
 export const ENV_VARIABLES = {
     PARJS_APP_ID: "library.inlang.paraglideJs",
     PARJS_POSTHOG_TOKEN: undefined,
-    PARJS_PACKAGE_VERSION: "2.3.0",
+    PARJS_PACKAGE_VERSION: "2.3.2",
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "license": "MIT",
   "publishConfig": {
     "access": "public",