@inlang/paraglide-js 2.0.1 → 2.0.3

package/dist/compiler/compile-bundle.test.js

@@ -95,3 +95,54 @@ test("compiles bundles with arbitrary module identifiers", async () => {
     });
     expect(result.bundle.code).includes(`export { ${toSafeModuleId("$p@44🍌")} as "$p@44🍌" }`);
 });
+test("handles message pattern with duplicate variable references", async () => {
+    const mockBundle = {
+        id: "date_last_days",
+        declarations: [
+            { type: "input-variable", name: "days" },
+            { type: "input-variable", name: "days" },
+        ],
+        messages: [
+            {
+                id: "date_last_days",
+                bundleId: "date_last_days",
+                locale: "en",
+                selectors: [],
+                variants: [
+                    {
+                        id: "1",
+                        messageId: "date_last_days",
+                        matches: [],
+                        pattern: [
+                            { type: "text", value: "Last " },
+                            {
+                                type: "expression",
+                                arg: { type: "variable-reference", name: "days" },
+                            },
+                            { type: "text", value: " days, showing " },
+                            {
+                                type: "expression",
+                                arg: { type: "variable-reference", name: "days" },
+                            },
+                            { type: "text", value: " items" },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+    const result = compileBundle({
+        fallbackMap: {
+            en: "en",
+        },
+        bundle: mockBundle,
+        messageReferenceExpression: (locale) => `${toSafeModuleId(locale)}.date_last_days`,
+    });
+    // The JSDoc should not have duplicate parameters
+    expect(result.bundle.code).toContain("@param {{ days: NonNullable<unknown> }} inputs");
+    expect(result.bundle.code).not.toContain("days: NonNullable<unknown>, days: NonNullable<unknown>");
+    // Check that the pattern is compiled correctly
+    const enMessage = result.messages?.en;
+    expect(enMessage).toBeDefined();
+    expect(enMessage?.code).toContain("Last ${i.days} days, showing ${i.days} items");
+});

package/dist/compiler/compile-message.test.js

@@ -69,7 +69,7 @@ test("compiles a message with variants", async () => {
     ];
     const compiled = compileMessage(declarations, message, variants);
     const { some_message } = await import("data:text/javascript;base64," +
-        btoa("export const some_message =" + compiled.code));
+        btoa("export const some_message = " + compiled.code));
     expect(some_message({ fistInput: 1, secondInput: 2 })).toBe("The inputs are 1 and 2");
     expect(some_message({ fistInput: 3, secondInput: 4 })).toBe("Catch all");
     expect(some_message({ fistInput: 1, secondInput: 5 })).toBe("Catch all");

package/dist/compiler/jsdoc-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsdoc-types.d.ts","sourceRoot":"","sources":["../../src/compiler/jsdoc-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC9C,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB,GAAG,MAAM,CAOT;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAU1D"}
+{"version":3,"file":"jsdoc-types.d.ts","sourceRoot":"","sources":["../../src/compiler/jsdoc-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC9C,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB,GAAG,MAAM,CAOT;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAoB1D"}

package/dist/compiler/jsdoc-types.js

@@ -17,7 +17,13 @@ export function inputsType(inputs) {
     if (inputs.length === 0) {
         return "{}";
     }
-    const inputParams = inputs
+    // Deduplicate inputs by name to avoid TypeScript errors with duplicate properties in JSDoc
+    const uniqueInputMap = new Map();
+    for (const input of inputs) {
+        uniqueInputMap.set(input.name, input);
+    }
+    const uniqueInputs = Array.from(uniqueInputMap.values());
+    const inputParams = uniqueInputs
         .map((input) => {
         return `${input.name}: NonNullable<unknown>`;
     })

package/dist/compiler/jsdoc-types.test.d.ts

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

package/dist/compiler/jsdoc-types.test.d.ts.map

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

package/dist/compiler/jsdoc-types.test.js

@@ -0,0 +1,26 @@
+import { test, expect } from "vitest";
+import { inputsType, jsDocBundleFunctionTypes } from "./jsdoc-types.js";
+test("inputsType generates unique parameter types even when the same input appears multiple times", () => {
+    // Simulate a case where the same input appears multiple times (like in a translation with placeholders)
+    const inputs = [
+        { name: "days", type: "input-variable" },
+        { name: "days", type: "input-variable" }, // Duplicated input
+    ];
+    // The generated input type should only include each parameter once
+    const result = inputsType(inputs);
+    expect(result).toBe("{ days: NonNullable<unknown> }");
+    // It should not generate a duplicate parameter
+    expect(result).not.toBe("{ days: NonNullable<unknown>, days: NonNullable<unknown> }");
+});
+test("jsDocBundleFunctionTypes correctly handles messages with duplicate inputs", () => {
+    const inputs = [
+        { name: "days", type: "input-variable" },
+        { name: "days", type: "input-variable" }, // Duplicated input
+    ];
+    const locales = ["en-us", "de-de"];
+    const result = jsDocBundleFunctionTypes({ inputs, locales });
+    // The JSDoc should only include each parameter once
+    expect(result).toContain("@param {{ days: NonNullable<unknown> }} inputs");
+    // It should not contain duplicated parameters
+    expect(result).not.toContain("@param {{ days: NonNullable<unknown>, days: NonNullable<unknown> }} inputs");
+});

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,CAyDpB;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":"AA+BA;;;;;;;;;;;GAWG;AACH,sBAFU,MAAM,MAAM,CA8DpB;AA4BF;;;;;;;;;;;;;;GAcG;AACH,iCAFU,CAAC,EAAE,EAAE,MAAM,MAAM,KAAK,IAAI,CAIlC"}

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

@@ -45,7 +45,10 @@ export let getLocale = () => {
         else if (strat === "baseLocale") {
             locale = baseLocale;
         }
-        else if (TREE_SHAKE_URL_STRATEGY_USED && strat === "url" && !isServer && typeof window !== 'undefined') {
+        else if (TREE_SHAKE_URL_STRATEGY_USED &&
+            strat === "url" &&
+            !isServer &&
+            typeof window !== "undefined") {
             locale = extractLocaleFromUrl(window.location.href);
         }
         else if (TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED &&

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

@@ -41,7 +41,7 @@ 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") {
                 continue;
             }
             // set the cookie

package/dist/compiler/server/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/server/middleware.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,oCA9Ca,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAEnF,OAAO,CAAC,QAAQ,CAAC,CA2I7B"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/server/middleware.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,oCA9Ca,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAEnF,OAAO,CAAC,QAAQ,CAAC,CA0H7B"}

package/dist/compiler/server/middleware.js

@@ -61,79 +61,65 @@ import * as runtime from "./runtime.js";
  * ```
  */
 export async function paraglideMiddleware(request, resolve) {
-    try {
-        if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
-            const { AsyncLocalStorage } = await import("async_hooks");
-            runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
-        }
-        else if (!runtime.serverAsyncLocalStorage) {
-            runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
-        }
-        const locale = runtime.extractLocaleFromRequest(request);
-        const origin = new URL(request.url).origin;
-        // if the client makes a request to a URL that doesn't match
-        // the localizedUrl, redirect the client to the localized URL
-        if (request.headers.get("Sec-Fetch-Dest") === "document" &&
-            runtime.strategy.includes("url")) {
-            const localizedUrl = runtime.localizeUrl(request.url, { locale });
-            if (normalizeURL(localizedUrl.href) !== normalizeURL(request.url)) {
-                return Response.redirect(localizedUrl, 307);
-            }
-        }
-        // If the strategy includes "url", we need to de-localize the URL
-        // before passing it to the server middleware.
-        //
-        // The middleware is responsible for mapping a localized URL to the
-        // de-localized URL e.g. `/en/about` to `/about`. Otherwise,
-        // the server can't render the correct page.
-        const newRequest = runtime.strategy.includes("url")
-            ? new Request(runtime.deLocalizeUrl(request.url), request)
-            : // need to create a new request object because some metaframeworks (nextjs!) throw otherwise
-                // https://github.com/opral/inlang-paraglide-js/issues/411
-                new Request(request);
-        // the message functions that have been called in this request
-        /** @type {Set<string>} */
-        const messageCalls = new Set();
-        const response = await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest }));
-        // Only modify HTML responses
-        if (runtime.experimentalMiddlewareLocaleSplitting &&
-            response.headers.get("Content-Type")?.includes("html")) {
-            const body = await response.text();
-            const messages = [];
-            // using .values() to avoid polyfilling in older projects. else the following error is thrown
-            // Type 'Set<string>' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.
-            for (const messageCall of Array.from(messageCalls)) {
-                const [id, locale] = 
-                /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
-                messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
-            }
-            const script = `<script>globalThis.__paraglide_ssr = { ${messages.join(",")} }</script>`;
-            // Insert the script before the closing head tag
-            const newBody = body.replace("</head>", `${script}</head>`);
-            // Create a new response with the modified body
-            // Clone all headers except Content-Length which will be set automatically
-            const newHeaders = new Headers(response.headers);
-            newHeaders.delete("Content-Length"); // Let the browser calculate the correct length
-            return new Response(newBody, {
-                status: response.status,
-                statusText: response.statusText,
-                headers: newHeaders,
-            });
+    if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
+        const { AsyncLocalStorage } = await import("async_hooks");
+        runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+    }
+    else if (!runtime.serverAsyncLocalStorage) {
+        runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
+    }
+    const locale = runtime.extractLocaleFromRequest(request);
+    const origin = new URL(request.url).origin;
+    // if the client makes a request to a URL that doesn't match
+    // the localizedUrl, redirect the client to the localized URL
+    if (request.headers.get("Sec-Fetch-Dest") === "document" &&
+        runtime.strategy.includes("url")) {
+        const localizedUrl = runtime.localizeUrl(request.url, { locale });
+        if (normalizeURL(localizedUrl.href) !== normalizeURL(request.url)) {
+            return Response.redirect(localizedUrl, 307);
         }
-        return response;
     }
-    catch (error) {
-        // Log the error with stack trace to help with debugging
-        console.error("[Paraglide Middleware Error]", error);
-        // Return a helpful error response
-        // Use text/plain to ensure the error is readable in the browser
-        return new Response(`Paraglide middleware error: ${ /** @type {any} */(error)?.message}\n`, {
-            status: 500,
-            headers: {
-                "Content-Type": "text/plain; charset=utf-8",
-            },
+    // If the strategy includes "url", we need to de-localize the URL
+    // before passing it to the server middleware.
+    //
+    // The middleware is responsible for mapping a localized URL to the
+    // de-localized URL e.g. `/en/about` to `/about`. Otherwise,
+    // the server can't render the correct page.
+    const newRequest = runtime.strategy.includes("url")
+        ? new Request(runtime.deLocalizeUrl(request.url), request)
+        : // need to create a new request object because some metaframeworks (nextjs!) throw otherwise
+            // https://github.com/opral/inlang-paraglide-js/issues/411
+            new Request(request);
+    // the message functions that have been called in this request
+    /** @type {Set<string>} */
+    const messageCalls = new Set();
+    const response = await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest }));
+    // Only modify HTML responses
+    if (runtime.experimentalMiddlewareLocaleSplitting &&
+        response.headers.get("Content-Type")?.includes("html")) {
+        const body = await response.text();
+        const messages = [];
+        // using .values() to avoid polyfilling in older projects. else the following error is thrown
+        // Type 'Set<string>' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.
+        for (const messageCall of Array.from(messageCalls)) {
+            const [id, locale] = 
+            /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
+            messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
+        }
+        const script = `<script>globalThis.__paraglide_ssr = { ${messages.join(",")} }</script>`;
+        // Insert the script before the closing head tag
+        const newBody = body.replace("</head>", `${script}</head>`);
+        // Create a new response with the modified body
+        // Clone all headers except Content-Length which will be set automatically
+        const newHeaders = new Headers(response.headers);
+        newHeaders.delete("Content-Length"); // Let the browser calculate the correct length
+        return new Response(newBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
         });
     }
+    return response;
 }
 /**
  * Normalize url for comparison.

package/dist/compiler/server/middleware.test.js

@@ -433,3 +433,22 @@ test("only redirects if the request.headers.get('Sec-Fetch-Dest') === 'document'
     // Middleware should be called since no redirect for API requests
     expect(apiMiddlewareResolveWasCalled).toBe(true);
 });
+// https://github.com/opral/inlang-paraglide-js/issues/477
+test("does not catch errors thrown by downstream resolve call", async () => {
+    const runtime = await createParaglide({
+        project: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en"],
+            },
+        }),
+        compilerOptions: {
+            strategy: ["url"],
+        },
+    });
+    await expect(() => runtime.paraglideMiddleware(new Request(new URL("https://example.com/page"), {
+        headers: { "Sec-Fetch-Dest": "document" },
+    }), () => {
+        throw new Error("Downstream error");
+    })).rejects.toThrow();
+});

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.0.1",
+    PARJS_PACKAGE_VERSION: "2.0.3",
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -20,6 +20,7 @@
     "./dist",
     "./bin"
   ],
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
     "./urlpattern-polyfill": "./dist/urlpattern-polyfill/index.js"
@@ -49,7 +50,7 @@
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.20.0",
     "vitest": "2.1.8",
-    "@inlang/paraglide-js": "2.0.1",
+    "@inlang/paraglide-js": "2.0.3",
     "@opral/tsconfig": "1.1.0",
     "@inlang/plugin-message-format": "4.0.0"
   },