@inlang/paraglide-js 2.2.0 → 2.3.1

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

@@ -1,2 +1,2 @@
-export declare const paraglideRspackPlugin: (options: import("../index.js").CompilerOptions) => RspackPluginInstance;
+export declare const paraglideRspackPlugin: (options: import("../index.js").CompilerOptions) => import("unplugin").RspackPluginInstance;
 //# sourceMappingURL=rspack.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rspack.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/rspack.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,0EAAsC,CAAC"}
+{"version":3,"file":"rspack.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/rspack.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,6FAAsC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"unplugin.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/unplugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAMhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAavE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,eAAe,CAyH3D,CAAC"}
+{"version":3,"file":"unplugin.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/unplugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAMhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAavE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,eAAe,CA2H3D,CAAC"}

package/dist/bundler-plugins/unplugin.js

@@ -36,6 +36,8 @@ export const unpluginFactory = (args) => ({
         catch (error) {
             logger.error("Failed to compile project:", error.message);
             logger.info("Please check your translation files for syntax errors.");
+            if (isProduction)
+                throw error;
         }
         finally {
             // in any case add the files to watch
@@ -118,6 +120,8 @@ export const unpluginFactory = (args) => ({
             catch (error) {
                 logger.warn("Failed to compile project:", error.message);
                 logger.warn("Please check your translation files for syntax errors.");
+                if (isProduction)
+                    throw error;
             }
         });
     },

package/dist/bundler-plugins/unplugin.test.d.ts

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

package/dist/bundler-plugins/unplugin.test.d.ts.map

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

package/dist/bundler-plugins/unplugin.test.js

@@ -0,0 +1,75 @@
+import { test, expect, beforeEach, afterEach, vi } from "vitest";
+import { paraglideVitePlugin } from "../bundler-plugins/vite.js";
+import consola from "consola";
+import { memfs } from "memfs";
+import { loadProjectInMemory, newProject, saveProjectToDirectory, } from "@inlang/sdk";
+let originalNodeEnv;
+beforeEach(() => {
+    originalNodeEnv = process.env.NODE_ENV;
+    // Mock logging methods to suppress error messages in tests
+    consola.mockTypes(() => vi.fn());
+});
+afterEach(() => {
+    if (originalNodeEnv !== undefined) {
+        process.env.NODE_ENV = originalNodeEnv;
+    }
+    else {
+        delete process.env.NODE_ENV;
+    }
+});
+test("vite plugin does not throw when compilation is successful", async () => {
+    // Create and save a viable project to the virtual file system
+    const project = await loadProjectInMemory({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de", "fr"],
+            },
+        }),
+    });
+    const fs = memfs().fs;
+    await saveProjectToDirectory({
+        project,
+        path: "/project.inlang",
+        fs: fs.promises,
+    });
+    const plugin = paraglideVitePlugin({
+        project: "/project.inlang",
+        outdir: "/test-output",
+        fs: fs,
+    });
+    const mockContext = {
+        addWatchFile: () => { },
+    };
+    await expect(plugin.buildStart?.call(mockContext)).resolves.toBeUndefined();
+});
+test("vite plugin does not throw on compilation errors in development", async () => {
+    process.env.NODE_ENV = "development";
+    // Use memfs with no project (simulates missing project)
+    const fs = memfs().fs;
+    const plugin = paraglideVitePlugin({
+        project: "/non-existent-project.inlang",
+        outdir: "/test-output",
+        fs: fs,
+    });
+    const mockContext = {
+        addWatchFile: () => { },
+    };
+    // In development mode - should catch errors and NOT throw
+    await expect(plugin.buildStart?.call(mockContext)).resolves.toBeUndefined();
+});
+test("vite plugin throws on compilation errors at build time", async () => {
+    process.env.NODE_ENV = "production";
+    // Use memfs with no project (simulates missing project)
+    const fs = memfs().fs;
+    const plugin = paraglideVitePlugin({
+        project: "/non-existent-project.inlang",
+        outdir: "/test-output",
+        fs: fs,
+    });
+    const mockContext = {
+        addWatchFile: () => { },
+    };
+    // In production mode - should throw the error
+    await expect(plugin.buildStart?.call(mockContext)).rejects.toThrow();
+});

package/dist/compiler/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compiler/compile.ts"],"names":[],"mappings":"AASA,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,uBAAuB,CAAC;AAS/B,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CACjD,CAAC;AAIF;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAC5B,OAAO,EAAE,eAAe,GAAG;IAC1B,mBAAmB,CAAC,EAAE,iBAAiB,CAAC;CACxC,GACC,OAAO,CAAC,iBAAiB,CAAC,CAqE5B"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compiler/compile.ts"],"names":[],"mappings":"AASA,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,uBAAuB,CAAC;AAS/B,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CACjD,CAAC;AAIF;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAC5B,OAAO,EAAE,eAAe,GAAG;IAC1B,mBAAmB,CAAC,EAAE,iBAAiB,CAAC;CACxC,GACC,OAAO,CAAC,iBAAiB,CAAC,CAuE5B"}

package/dist/compiler/compile.js

@@ -3,7 +3,10 @@ import path from "node:path";
 import { ENV_VARIABLES } from "../services/env-variables/index.js";
 import { compileProject } from "./compile-project.js";
 import { writeOutput } from "../services/file-handling/write-output.js";
-import { getLocalAccount, saveLocalAccount, } from "../services/account/index.js";
+// import {
+// 	getLocalAccount,
+// 	saveLocalAccount,
+// } from "../services/account/index.js";
 import { defaultCompilerOptions, } from "./compiler-options.js";
 import { Logger } from "../services/logger/index.js";
 // This is a workaround to prevent multiple compilations from running at the same time.
@@ -35,11 +38,11 @@ export async function compile(options) {
         try {
             const fs = withDefaultOptions.fs ?? (await import("node:fs"));
             const absoluteOutdir = path.resolve(process.cwd(), withDefaultOptions.outdir);
-            const localAccount = getLocalAccount({ fs });
+            // const localAccount = getLocalAccount({ fs });
             const project = await loadProjectFromDirectory({
                 path: withDefaultOptions.project,
                 fs,
-                account: localAccount,
+                // account: localAccount,
                 appId: ENV_VARIABLES.PARJS_APP_ID,
             });
             const output = await compileProject({
@@ -53,13 +56,15 @@ export async function compile(options) {
                 fs: fs.promises,
                 previousOutputHashes: options.previousCompilation?.outputHashes,
             });
-            if (!localAccount) {
-                const activeAccount = await project.lix.db
-                    .selectFrom("active_account")
-                    .selectAll()
-                    .executeTakeFirstOrThrow();
-                saveLocalAccount({ fs, account: activeAccount });
-            }
+            // if (!localAccount) {
+            // 	const activeAccount = await project.lix.db
+            // 		.selectFrom("active_account as aa")
+            // 		.innerJoin("account_all as a", "a.id", "aa.account_id")
+            // 		.where("a.lixcol_version_id", "=", "global")
+            // 		.select(["a.id", "a.name"])
+            // 		.executeTakeFirstOrThrow();
+            // 	saveLocalAccount({ fs, account: activeAccount });
+            // }
             const warningsAndErrors = await project.errors.get();
             for (const warningOrError of warningsAndErrors) {
                 logger.warn(warningOrError);

package/dist/compiler/compile.test.js

@@ -30,7 +30,7 @@ test("loads a project and compiles it", async () => {
     //runtime.js and messages.js are always compiled with the default options
     expect(files).toEqual(expect.arrayContaining(["runtime.js", "server.js", "messages.js"]));
 });
-test("loads a local account from app data if exists", async () => {
+test.skip("loads a local account from app data if exists", async () => {
     const accountPath = getAccountFilePath();
     const fs = memfs({
         [accountPath]: JSON.stringify({ id: "mock", name: "test" }),
@@ -56,7 +56,7 @@ test("loads a local account from app data if exists", async () => {
     });
     expect(spy).toHaveBeenCalledWith(accountPath, "utf8");
 });
-test("saves the local account to app data if not exists", async () => {
+test.skip("saves the local account to app data if not exists", async () => {
     const accountPath = getAccountFilePath();
     const fs = memfs().fs;
     const project = await loadProjectInMemory({

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<void> | void}
  */
 export let setLocale: (newLocale: Locale, options?: {
     reload?: boolean;
-}) => void;
+}) => Promise<void> | 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,IAAI,CAAC,GAAG,IAAI,CAmGnF;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<void> | 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) {
@@ -85,8 +106,9 @@ export let setLocale = (newLocale, options) => {
                 // Handle async setLocale - fire and forget
                 if (result instanceof Promise) {
                     result.catch((error) => {
-                        console.warn(`Custom strategy "${strat}" setLocale failed:`, error);
+                        error.message = `Custom strategy "${strat}" setLocale failed: ${error.message}`;
                     });
+                    customSetLocalePromises.push(result);
                 }
             }
         }
@@ -95,13 +117,14 @@ 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);
         }
     }
     return;

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

@@ -317,6 +317,102 @@ test("calls setLocale on multiple custom strategies", async () => {
     expect(customLocale1).toBe("de");
     expect(customLocale2).toBe("de");
 });
+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");
+        },
+    });
+    await expect(() => runtime.setLocale("de")).rejects.toThrowError(`Custom strategy "custom-async" setLocale failed: 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.d.ts

@@ -1,6 +1,6 @@
 export declare const ENV_VARIABLES: {
     PARJS_APP_ID: string;
-    PARJS_POSTHOG_TOKEN: string;
+    PARJS_POSTHOG_TOKEN: undefined;
     PARJS_PACKAGE_VERSION: string;
 };
 //# sourceMappingURL=index.d.ts.map

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

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

package/package.json

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