@inlang/paraglide-js 2.0.5 → 2.0.6

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

@@ -545,6 +545,30 @@ describe.each([
             runtime.setLocale("en-US");
             expect(m.missing_in_en_US()).toBe("Fallback message.");
         });
+        test("arbitrary module identifiers", async () => {
+            const project = await loadProjectInMemory({
+                blob: await newProject({
+                    settings: { locales: ["en"], baseLocale: "en" },
+                }),
+            });
+            await insertBundleNested(project.db, createBundleNested({
+                id: "happy🍌",
+                messages: [
+                    {
+                        locale: "en",
+                        variants: [{ pattern: [{ type: "text", value: "Hello" }] }],
+                    },
+                ],
+            }));
+            const output = await compileProject({
+                project,
+                compilerOptions,
+            });
+            const code = await bundleCode(output, `export * as m from "./paraglide/messages.js"
+					export * as runtime from "./paraglide/runtime.js"`);
+            const { m } = await importCode(code);
+            expect(m["happy🍌"]()).toBe("Hello");
+        });
     });
     test("case sensitivity handling for bundle IDs", async () => {
         // skip local modules for now because the option might get removed in the future
@@ -719,6 +743,27 @@ const mockBundles = [
             },
         ],
     }),
+    createBundleNested({
+        id: "Sad_penguin_bundle",
+        messages: [
+            {
+                locale: "en",
+                variants: [
+                    { pattern: [{ type: "text", value: "Capital Sad penguin" }] },
+                ],
+            },
+            {
+                locale: "de",
+                variants: [
+                    {
+                        pattern: [
+                            { type: "text", value: "Grossgeschriebenes Sad penguin" },
+                        ],
+                    },
+                ],
+            },
+        ],
+    }),
     {
         id: "depressed_dog",
         declarations: [

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;AAQ/B,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CACjD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAC5B,OAAO,EAAE,eAAe,GAAG;IAC1B,mBAAmB,CAAC,EAAE,iBAAiB,CAAC;CACxC,GACC,OAAO,CAAC,iBAAiB,CAAC,CA+D5B"}
+{"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"}

package/dist/compiler/compile.js

@@ -5,9 +5,11 @@ import { compileProject } from "./compile-project.js";
 import { writeOutput } from "../services/file-handling/write-output.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.
 // https://github.com/opral/inlang-paraglide-js/issues/320#issuecomment-2596951222
 let compilationInProgress = null;
+const logger = new Logger();
 /**
  * Loads, compiles, and writes the output to disk.
  *
@@ -58,6 +60,10 @@ export async function compile(options) {
                     .executeTakeFirstOrThrow();
                 saveLocalAccount({ fs, account: activeAccount });
             }
+            const warningsAndErrors = await project.errors.get();
+            for (const warningOrError of warningsAndErrors) {
+                logger.warn(warningOrError);
+            }
             await project.close();
             return { outputHashes };
         }

package/dist/compiler/compile.test.js

@@ -4,6 +4,7 @@ import { test, expect, vi } from "vitest";
 import { compile } from "./compile.js";
 import { getAccountFilePath } from "../services/account/index.js";
 import { defaultCompilerOptions } from "./compiler-options.js";
+import consola from "consola";
 test("loads a project and compiles it", async () => {
     const project = await loadProjectInMemory({
         blob: await newProject({
@@ -258,3 +259,55 @@ test("default compiler options should include cookied, variable and baseLocale t
         "baseLocale",
     ]);
 });
+test("emits warnings for modules that couldn't be imported locally", async () => {
+    const project = await loadProjectInMemory({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de", "fr"],
+                modules: ["./non-existent-paraglide-plugin.js"],
+            },
+        }),
+    });
+    const mock = vi.fn();
+    consola.mockTypes(() => mock);
+    const fs = memfs().fs;
+    // save project to directory to test loading
+    await saveProjectToDirectory({
+        project,
+        path: "/project.inlang",
+        fs: fs.promises,
+    });
+    await compile({
+        project: "/project.inlang",
+        outdir: "/output",
+        fs: fs,
+    });
+    expect(mock).toHaveBeenCalled();
+});
+test("emits warnings for modules that couldn't be imported via http", async () => {
+    const project = await loadProjectInMemory({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de", "fr"],
+                modules: ["https://example.com/non-existent-paraglide-plugin.js"],
+            },
+        }),
+    });
+    const mock = vi.fn();
+    consola.mockTypes(() => mock);
+    const fs = memfs().fs;
+    // save project to directory to test loading
+    await saveProjectToDirectory({
+        project,
+        path: "/project.inlang",
+        fs: fs.promises,
+    });
+    await compile({
+        project: "/project.inlang",
+        outdir: "/output",
+        fs: fs,
+    });
+    expect(mock).toHaveBeenCalled();
+});

package/dist/compiler/output-structure/locale-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locale-modules.d.ts","sourceRoot":"","sources":["../../../src/compiler/output-structure/locale-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAIvE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAE1E;AAED,wBAAgB,cAAc,CAC7B,eAAe,EAAE,0BAA0B,EAAE,EAC7C,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,YAAY,CAAC,EACzD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAC7C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoDxB"}
+{"version":3,"file":"locale-modules.d.ts","sourceRoot":"","sources":["../../../src/compiler/output-structure/locale-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAavE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAY1E;AAED,wBAAgB,cAAc,CAC7B,eAAe,EAAE,0BAA0B,EAAE,EAC7C,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,YAAY,CAAC,EACzD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAC7C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgIxB"}

package/dist/compiler/output-structure/locale-modules.js

@@ -1,15 +1,66 @@
 import { toSafeModuleId } from "../safe-module-id.js";
 import { inputsType } from "../jsdoc-types.js";
+// Helper function to escape special characters in a string for use in a regular expression
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// This map will be used to track which bundle IDs have been renamed to which unique IDs
+// It will be populated during the generateOutput function and used in messageReferenceExpression
+const bundleIdToUniqueIdMap = new Map();
 export function messageReferenceExpression(locale, bundleId) {
-    return `${toSafeModuleId(locale)}.${toSafeModuleId(bundleId)}`;
+    // First convert to safe module ID
+    const safeModuleId = toSafeModuleId(bundleId);
+    // Check if this bundleId has been mapped to a unique identifier
+    const uniqueId = bundleIdToUniqueIdMap.get(bundleId);
+    if (uniqueId) {
+        return `${toSafeModuleId(locale)}.${uniqueId}`;
+    }
+    // Otherwise, return the default safe module ID
+    return `${toSafeModuleId(locale)}.${safeModuleId}`;
 }
 export function generateOutput(compiledBundles, settings, fallbackMap) {
+    // Create a map to track module IDs in the index file to avoid duplicates
+    const indexModuleIdMap = new Map();
+    // Process the bundles to ensure no duplicate bundle IDs
+    // Generate unique moduleIds for duplicate IDs
+    const processedBundleCodes = compiledBundles
+        .map(({ bundle }) => {
+        const bundleId = bundle.node.id;
+        const bundleModuleId = toSafeModuleId(bundleId);
+        // Check if this safe module ID has been used before
+        if (indexModuleIdMap.has(bundleModuleId)) {
+            // Create a unique identifier by adding a counter
+            let counter = 1;
+            let uniqueModuleId = `${bundleModuleId}${counter}`;
+            while (indexModuleIdMap.has(uniqueModuleId)) {
+                counter++;
+                uniqueModuleId = `${bundleModuleId}${counter}`;
+            }
+            // Modify the code to use the unique identifier
+            const modifiedCode = bundle.code
+                .replace(new RegExp(`const ${bundleModuleId} =`, "g"), `const ${uniqueModuleId} =`)
+                .replace(new RegExp(`export const ${bundleModuleId} =`, "g"), `export const ${uniqueModuleId} =`)
+                .replace(new RegExp(`export { ${bundleModuleId}`, "g"), `export { ${uniqueModuleId}`)
+                .replace(
+            // Also update the trackMessageCall to use the new identifier
+            new RegExp(`trackMessageCall\\("${escapeRegExp(bundleId)}"`, "g"), `trackMessageCall("${bundleId}"`);
+            // Store the unique ID mapping
+            indexModuleIdMap.set(uniqueModuleId, bundleId);
+            // Also store in the global map for messageReferenceExpression to use
+            bundleIdToUniqueIdMap.set(bundleId, uniqueModuleId);
+            return modifiedCode;
+        }
+        // Store the mapping
+        indexModuleIdMap.set(bundleModuleId, bundleId);
+        return bundle.code;
+    })
+        .join("\n");
     const indexFile = [
         `import { getLocale, trackMessageCall, experimentalMiddlewareLocaleSplitting, isServer } from "../runtime.js"`,
         settings.locales
             .map((locale) => `import * as ${toSafeModuleId(locale)} from "./${locale}.js"`)
             .join("\n"),
-        compiledBundles.map(({ bundle }) => bundle.code).join("\n"),
+        processedBundleCodes,
     ].join("\n");
     const output = {
         ["messages/_index.js"]: indexFile,
@@ -18,24 +69,39 @@ export function generateOutput(compiledBundles, settings, fallbackMap) {
     for (const locale of settings.locales) {
         const filename = `messages/${locale}.js`;
         let file = "";
+        // Keep track of module IDs to avoid duplicates
+        const moduleIdMap = new Map();
         for (const compiledBundle of compiledBundles) {
             const compiledMessage = compiledBundle.messages[locale];
-            const bundleModuleId = toSafeModuleId(compiledBundle.bundle.node.id);
             const bundleId = compiledBundle.bundle.node.id;
+            const bundleModuleId = toSafeModuleId(compiledBundle.bundle.node.id);
+            // Check if this module ID has already been used
+            let uniqueModuleId = bundleModuleId;
+            if (moduleIdMap.has(bundleModuleId)) {
+                // If it has, create a unique ID by adding an index
+                let counter = 1;
+                uniqueModuleId = `${bundleModuleId}${counter}`;
+                while (moduleIdMap.has(uniqueModuleId)) {
+                    counter++;
+                    uniqueModuleId = `${bundleModuleId}${counter}`;
+                }
+            }
+            // Store this module ID
+            moduleIdMap.set(uniqueModuleId, bundleId);
             const inputs = compiledBundle.bundle.node.declarations?.filter((decl) => decl.type === "input-variable") ?? [];
             if (!compiledMessage) {
                 const fallbackLocale = fallbackMap[locale];
                 if (fallbackLocale) {
                     // use the fall back locale e.g. render the message in English if the German message is missing
-                    file += `\nexport { ${bundleModuleId} } from "./${fallbackLocale}.js"`;
+                    file += `\nexport { ${uniqueModuleId} } from "./${fallbackLocale}.js"`;
                 }
                 else {
                     // no fallback exists, render the bundleId
-                    file += `\n/** @type {(inputs: ${inputsType(inputs)}) => string} */ */\nexport const ${bundleModuleId} = () => '${bundleId}'`;
+                    file += `\n/** @type {(inputs: ${inputsType(inputs)}) => string} */\nexport const ${uniqueModuleId} = () => '${bundleId}'`;
                 }
                 continue;
             }
-            file += `\n\nexport const ${bundleModuleId} = ${compiledMessage.code}`;
+            file += `\n\nexport const ${uniqueModuleId} = ${compiledMessage.code}`;
         }
         // add import if used
         if (file.includes("registry.")) {

package/dist/compiler/output-structure/locale-modules.test.js

@@ -59,3 +59,47 @@ test("the files should include files for each locale, even if there are no messa
     expect(output).toHaveProperty("messages/de.js");
     expect(output).toHaveProperty("messages/fr.js");
 });
+test("should handle case sensitivity in message IDs correctly", () => {
+    const bundles = [
+        {
+            bundle: {
+                code: 'console.log("bundle code");',
+                node: {
+                    id: "sad_penguin_bundle",
+                },
+            },
+            messages: {
+                en: {
+                    code: 'console.log("sad_penguin_bundle");',
+                    node: {},
+                },
+            },
+        },
+        {
+            bundle: {
+                code: 'console.log("bundle code");',
+                node: {
+                    id: "Sad_penguin_bundle",
+                },
+            },
+            messages: {
+                en: {
+                    code: 'console.log("Sad_penguin_bundle");',
+                    node: {},
+                },
+            },
+        },
+    ];
+    const settings = {
+        locales: ["en"],
+        baseLocale: "en",
+    };
+    const fallbackMap = {};
+    const output = generateOutput(bundles, settings, fallbackMap);
+    // Check that the output exists
+    expect(output).toHaveProperty("messages/en.js");
+    // The exported constants should not conflict
+    const content = output["messages/en.js"];
+    expect(content).toContain("export const sad_penguin_bundle");
+    expect(content).toContain("export const sad_penguin_bundle1"); // or some other unique name
+});

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -32,7 +32,7 @@
     "unplugin": "^2.1.2",
     "urlpattern-polyfill": "^10.0.0",
     "@inlang/recommend-sherlock": "0.2.1",
-    "@inlang/sdk": "2.4.4"
+    "@inlang/sdk": "2.4.5"
   },
   "devDependencies": {
     "@eslint/js": "^9.18.0",
@@ -51,7 +51,7 @@
     "typescript-eslint": "^8.20.0",
     "vitest": "2.1.8",
     "@inlang/plugin-message-format": "4.0.0",
-    "@inlang/paraglide-js": "2.0.5",
+    "@inlang/paraglide-js": "2.0.6",
     "@opral/tsconfig": "1.1.0"
   },
   "keywords": [