@inlang/paraglide-js 2.0.0-beta.26 → 2.0.0-beta.28

package/README.md

@@ -2,4 +2,8 @@
 
 A compiler-based i18n library that emits tree-shakable message functions. This means that only the messages you actually use are loaded without asynchronous waterfalls.
 
-Visit https://inlang.com/m/gerre34r/library-inlang-paraglideJs to learn more.
+Visit https://inlang.com/m/gerre34r/library-inlang-paraglideJs to learn more.
+
+## Contributing
+
+Read the [CONTRIBUTING.md](https://github.com/opral/monorepo/blob/main/inlang/packages/paraglide/paraglide-js/CONTRIBUTING.md) file to learn more on how to contribute.

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;AAQvE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,eAAe,CAuF3D,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,CAmG3D,CAAC"}

package/dist/bundler-plugins/unplugin.js

@@ -5,6 +5,10 @@ import { nodeNormalizePath } from "../utilities/node-normalize-path.js";
 import { Logger } from "../services/logger/index.js";
 const PLUGIN_NAME = "unplugin-paraglide-js";
 const logger = new Logger();
+/**
+ * Default isServer which differs per bundler.
+ */
+let isServer;
 let previousCompilation;
 export const unpluginFactory = (args) => ({
     name: PLUGIN_NAME,
@@ -19,6 +23,7 @@ export const unpluginFactory = (args) => ({
                 // to avoid cleaning the output directory in watch mode,
                 // we only clean the output directory if there was no previous compilation
                 cleanOutdir: previousCompilation === undefined,
+                isServer,
                 ...args,
             });
             logger.success("Compilation complete");
@@ -48,6 +53,7 @@ export const unpluginFactory = (args) => ({
                 fs: wrappedFs,
                 previousCompilation,
                 cleanOutdir: false,
+                isServer,
                 ...args,
             });
             logger.success("Re-compilation complete");
@@ -63,6 +69,13 @@ export const unpluginFactory = (args) => ({
             logger.warn("Failed to re-compile project:", e.message);
         }
     },
+    vite: {
+        config: {
+            handler: () => {
+                isServer = "import.meta.env?.SSR ?? typeof window === 'undefined'";
+            },
+        },
+    },
     webpack(compiler) {
         compiler.options.resolve = {
             ...compiler.options.resolve,
@@ -77,7 +90,10 @@ export const unpluginFactory = (args) => ({
                 previousCompilation = await compile({
                     fs: wrappedFs,
                     previousCompilation,
-                    cleanOutdir: true,
+                    // clean dir needs to be false. otherwise webpack get's into a race condition
+                    // of deleting the output directory and writing files at the same time for
+                    // multi environment builds
+                    cleanOutdir: false,
                     ...args,
                 });
                 logger.success("Compilation complete");

package/dist/compiler/compile-bundle.d.ts

@@ -14,5 +14,6 @@ export type CompiledBundleWithMessages = {
 export declare const compileBundle: (args: {
     bundle: BundleNested;
     fallbackMap: Record<string, string | undefined>;
+    messageReferenceExpression: (locale: string, bundleId: string) => string;
 }) => CompiledBundleWithMessages;
 //# sourceMappingURL=compile-bundle.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compile-bundle.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK3C,MAAM,MAAM,0BAA0B,GAAG;IACxC,kDAAkD;IAClD,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,gDAAgD;IAChD,QAAQ,EAAE;QACT,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;KACpC,CAAC;CACF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,SAAU;IACnC,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAChD,KAAG,0BAyBH,CAAC"}
+{"version":3,"file":"compile-bundle.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK3C,MAAM,MAAM,0BAA0B,GAAG;IACxC,kDAAkD;IAClD,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,gDAAgD;IAChD,QAAQ,EAAE;QACT,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;KACpC,CAAC;CACF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,SAAU;IACnC,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAChD,0BAA0B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CACzE,KAAG,0BA0BH,CAAC"}

package/dist/compiler/compile-bundle.js

@@ -19,6 +19,7 @@ export const compileBundle = (args) => {
         bundle: compileBundleFunction({
             bundle: args.bundle,
             availableLocales: Object.keys(args.fallbackMap),
+            messageReferenceExpression: args.messageReferenceExpression,
         }),
         messages: compiledMessages,
     };
@@ -39,9 +40,13 @@ const compileBundleFunction = (args) => {
 */
 /* @__NO_SIDE_EFFECTS__ */
 ${isSafeBundleId ? "export " : ""}const ${safeBundleId} = (inputs${hasInputs ? "" : " = {}"}, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.${safeBundleId}(inputs) 
+	}
 	const locale = options.locale ?? getLocale()
+	trackMessageCall("${safeBundleId}", locale)
 	${args.availableLocales
-        .map((locale, index) => `${index > 0 ? "	" : ""}if (locale === "${locale}") return ${toSafeModuleId(locale)}.${safeBundleId}(inputs)`)
+        .map((locale, index) => `${index > 0 ? "	" : ""}if (locale === "${locale}") return ${args.messageReferenceExpression(locale, args.bundle.id)}(inputs)`)
         .join("\n")}
 	return "${args.bundle.id}"
 };`;

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

@@ -34,6 +34,7 @@ test("compiles to jsdoc", async () => {
             "en-US": "en",
         },
         bundle: mockBundle,
+        messageReferenceExpression: (locale) => `${toSafeModuleId(locale)}.blue_moon_bottle`,
     });
     expect(result.bundle.code).toMatchInlineSnapshot(`"/**
 * This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
@@ -49,7 +50,11 @@ test("compiles to jsdoc", async () => {
 */
 /* @__NO_SIDE_EFFECTS__ */
 export const blue_moon_bottle = (inputs, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.blue_moon_bottle(inputs) 
+	}
 	const locale = options.locale ?? getLocale()
+	trackMessageCall("blue_moon_bottle", locale)
 	if (locale === "en") return en.blue_moon_bottle(inputs)
 	if (locale === "en-US") return en_us.blue_moon_bottle(inputs)
 	return "blue_moon_bottle"
@@ -86,6 +91,7 @@ test("compiles bundles with arbitrary module identifiers", async () => {
     const result = compileBundle({
         fallbackMap: {},
         bundle: mockBundle,
+        messageReferenceExpression: (locale) => `${toSafeModuleId(locale)}.blue_moon_bottle`,
     });
     expect(result.bundle.code).includes(`export { ${toSafeModuleId("$p@44🍌")} as "$p@44🍌" }`);
 });

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

@@ -1 +1 @@
-{"version":3,"file":"compile-message.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAM3C;;;GAGG;AACH,eAAO,MAAM,cAAc,iBACZ,WAAW,EAAE,WAClB,OAAO,YACN,OAAO,EAAE,KACjB,QAAQ,CAAC,OAAO,CAUlB,CAAC"}
+{"version":3,"file":"compile-message.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK3C;;;GAGG;AACH,eAAO,MAAM,cAAc,iBACZ,WAAW,EAAE,WAClB,OAAO,YACN,OAAO,EAAE,KACjB,QAAQ,CAAC,OAAO,CAUlB,CAAC"}

package/dist/compiler/compile-message.js

@@ -2,7 +2,6 @@ import { compilePattern } from "./compile-pattern.js";
 import { doubleQuote } from "../services/codegen/quotes.js";
 import { inputsType } from "./jsdoc-types.js";
 import { compileLocalVariable } from "./compile-local-variable.js";
-import { toSafeModuleId } from "./safe-module-id.js";
 /**
  * Returns the compiled message as a string
  *
@@ -34,9 +33,7 @@ function compileMessageWithOneVariant(declarations, message, variants) {
             compiledLocalVariables.push(compileLocalVariable({ declaration, locale: message.locale }));
         }
     }
-    const safeModuleId = toSafeModuleId(message.bundleId);
-    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */
-export const ${safeModuleId} = (${hasInputs ? "i" : ""}) => {
+    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */ (${hasInputs ? "i" : ""}) => {
 	${compiledLocalVariables.join("\n\t")}return ${compiledPattern.code}
 };`;
     return { code, node: message };
@@ -84,9 +81,7 @@ function compileMessageWithMultipleVariants(declarations, message, variants) {
             compiledLocalVariables.push(compileLocalVariable({ declaration, locale: message.locale }));
         }
     }
-    const safeModuleId = toSafeModuleId(message.bundleId);
-    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */
-export const ${safeModuleId} = (${hasInputs ? "i" : ""}) => {${compiledLocalVariables.join("\n\t")}
+    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */ (${hasInputs ? "i" : ""}) => {${compiledLocalVariables.join("\n\t")}
 	${compiledVariants.join("\n\t")}
 	${hasCatchAll ? "" : `return "${message.bundleId}";`}
 };`;

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

@@ -1,7 +1,6 @@
 import { test, expect } from "vitest";
 import { compileMessage } from "./compile-message.js";
 import { createRegistry } from "./registry.js";
-import { toSafeModuleId } from "./safe-module-id.js";
 test("compiles a message with a single variant", async () => {
     const declarations = [];
     const message = {
@@ -19,7 +18,8 @@ test("compiles a message with a single variant", async () => {
         },
     ];
     const compiled = compileMessage(declarations, message, variants);
-    const { some_message } = await import("data:text/javascript;base64," + btoa(compiled.code));
+    const { some_message } = await import("data:text/javascript;base64," +
+        btoa("export const some_message =" + compiled.code));
     expect(some_message()).toBe("Hello");
 });
 test("compiles a message with variants", async () => {
@@ -68,7 +68,8 @@ test("compiles a message with variants", async () => {
         },
     ];
     const compiled = compileMessage(declarations, message, variants);
-    const { some_message } = await import("data:text/javascript;base64," + btoa(compiled.code));
+    const { some_message } = await import("data:text/javascript;base64," +
+        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");
@@ -119,7 +120,8 @@ test("compiles multi-variant message with a fallback in case the variants are no
         },
     ];
     const compiled = compileMessage(declarations, message, variants);
-    const { some_message } = await import("data:text/javascript;base64," + btoa(compiled.code));
+    const { some_message } = await import("data:text/javascript;base64," +
+        btoa("export const some_message = " + compiled.code));
     expect(some_message({ secondInput: 2 })).toBe("Catch all");
     expect(some_message({})).toBe("some_message");
 });
@@ -140,10 +142,7 @@ test("only emits input arguments when inputs exist", async () => {
         },
     ];
     const compiled = compileMessage(declarations, message, variants);
-    expect(compiled.code).toBe([
-        "/** @type {(inputs: {}) => string} */",
-        "export const some_message = () => {\n\treturn `Hello`\n};",
-    ].join("\n"));
+    expect(compiled.code).toBe("/** @type {(inputs: {}) => string} */ () => {\n\treturn `Hello`\n};");
 });
 // https://github.com/opral/inlang-paraglide-js/issues/379
 test("compiles messages that use plural()", async () => {
@@ -193,7 +192,7 @@ test("compiles messages that use plural()", async () => {
     const { plural_test } = await import("data:text/javascript;base64," +
         // bundling the registry inline to avoid managing module imports here
         btoa(createRegistry()) +
-        btoa(compiled.code.replace("registry.", "")));
+        btoa("export const plural_test = " + compiled.code.replace("registry.", "")));
     expect(plural_test({ count: 1 })).toBe("There is one cat.");
     expect(plural_test({ count: 2 })).toBe("There are many cats.");
     // INTL.plural will match "other" for undefined
@@ -242,7 +241,8 @@ test("compiles messages that use datetime()", async () => {
         const { datetime_test } = await import("data:text/javascript;base64," +
             // bundling the registry inline to avoid managing module imports here
             btoa(createRegistry()) +
-            btoa(compiled.code.replace("registry.", "")));
+            btoa("export const datetime_test =" +
+                compiled.code.replace("registry.", "")));
         return datetime_test;
     };
     const enMessage = await createMessage("en");
@@ -296,7 +296,8 @@ test("compiles messages that use datetime a function with options", async () =>
         const { datetime_test } = await import("data:text/javascript;base64," +
             // bundling the registry inline to avoid managing module imports here
             btoa(createRegistry()) +
-            btoa(compiled.code.replace("registry.", "")));
+            btoa("export const datetime_test = " +
+                compiled.code.replace("registry.", "")));
         return datetime_test;
     };
     const enMessage = await createMessage("en");
@@ -305,25 +306,3 @@ test("compiles messages that use datetime a function with options", async () =>
     expect(enMessage({ date: "2022-03-31" })).toMatch(/Today is March \d{1,2}\./);
     expect(deMessage({ date: "2022-03-31" })).toMatch(/Today is \d{1,2}\. März\./);
 });
-// https://github.com/opral/inlang-paraglide-js/issues/285
-test("compiles messages with arbitrary module identifiers", async () => {
-    const declarations = [];
-    const message = {
-        locale: "en",
-        bundleId: "$p@44🍌",
-        id: "message-id",
-        selectors: [],
-    };
-    const variants = [
-        {
-            id: "1",
-            messageId: "message-id",
-            matches: [],
-            pattern: [{ type: "text", value: "Hello" }],
-        },
-    ];
-    const compiled = compileMessage(declarations, message, variants);
-    const m = await import("data:text/javascript;base64," +
-        Buffer.from(compiled.code).toString("base64"));
-    expect(m[toSafeModuleId("$p@44🍌")]()).toBe("Hello");
-});

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

@@ -1 +1 @@
-{"version":3,"file":"compile-project.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-project.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,SAAgB;IAC1C,OAAO,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;CACrE,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgEjC,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC9C,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,GACpB,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAY1B"}
+{"version":3,"file":"compile-project.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-project.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,uBAAuB,CAAC;AAU/B;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,SAAgB;IAC1C,OAAO,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;CACrE,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsEjC,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC9C,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,GACpB,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAY1B"}

package/dist/compiler/compile-project.js

@@ -1,9 +1,16 @@
 import { compileBundle } from "./compile-bundle.js";
 import { selectBundleNested } from "@inlang/sdk";
 import { lookup } from "../services/lookup.js";
-import { generateLocaleModules } from "./output-structure/locale-modules.js";
-import { generateMessageModules } from "./output-structure/message-modules.js";
+import * as localeModules from "./output-structure/locale-modules.js";
+import * as messageModules from "./output-structure/message-modules.js";
 import { defaultCompilerOptions, } from "./compiler-options.js";
+import { createRuntimeFile } from "./runtime/create-runtime.js";
+import { createServerFile } from "./server/create-server-file.js";
+import { createRegistry } from "./registry.js";
+const outputStructures = {
+    "locale-modules": localeModules,
+    "message-modules": messageModules,
+};
 /**
  * Takes an inlang project and compiles it into a set of files.
  *
@@ -24,19 +31,31 @@ export const compileProject = async (args) => {
     //Maps each language to it's fallback
     //If there is no fallback, it will be undefined
     const fallbackMap = getFallbackMap(settings.locales, settings.baseLocale);
+    const outputStructure = outputStructures[optionsWithDefaults.outputStructure];
     const compiledBundles = bundles.map((bundle) => compileBundle({
         bundle,
         fallbackMap,
+        messageReferenceExpression: outputStructure.messageReferenceExpression,
     }));
-    const output = {};
-    if (optionsWithDefaults.outputStructure === "locale-modules") {
-        const regularOutput = generateLocaleModules(compiledBundles, settings, fallbackMap, optionsWithDefaults);
-        Object.assign(output, regularOutput);
-    }
-    if (optionsWithDefaults.outputStructure === "message-modules") {
-        const messageModuleOutput = generateMessageModules(compiledBundles, settings, fallbackMap, optionsWithDefaults);
-        Object.assign(output, messageModuleOutput);
-    }
+    const output = {
+        ["runtime.js"]: createRuntimeFile({
+            baseLocale: settings.baseLocale,
+            locales: settings.locales,
+            compilerOptions: optionsWithDefaults,
+        }),
+        ["server.js"]: createServerFile({
+            compiledBundles,
+            compilerOptions: optionsWithDefaults,
+        }),
+        ["registry.js"]: createRegistry(),
+        ["messages.js"]: [
+            "export * from './messages/_index.js'",
+            "// enabling auto-import by exposing all messages as m",
+            "export * as m from './messages/_index.js'",
+        ].join("\n"),
+    };
+    // generate the output modules
+    Object.assign(output, outputStructure.generateOutput(compiledBundles, settings, fallbackMap));
     if (optionsWithDefaults.emitGitIgnore) {
         output[".gitignore"] = ignoreDirectory;
     }

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

@@ -1,4 +1,5 @@
 import { expect, test, describe, vi, beforeEach } from "vitest";
+import { AsyncLocalStorage } from "async_hooks";
 import { createProject as typescriptProject, ts, } from "@ts-morph/bootstrap";
 import { Declaration, insertBundleNested, loadProjectInMemory, newProject, Pattern, VariableReference, } from "@inlang/sdk";
 import { compileProject } from "./compile-project.js";
@@ -354,6 +355,117 @@ describe.each([
             runtime.setLocale("en-US");
             expect(m.missingInGerman()).toBe("A simple message.");
         });
+        test("message tracking works", async () => {
+            const project = await loadProjectInMemory({
+                blob: await newProject({
+                    settings: { locales: ["en", "de", "fr"], baseLocale: "en" },
+                }),
+            });
+            // Add test messages
+            await insertBundleNested(project.db, createBundleNested({
+                id: "greeting",
+                messages: [
+                    {
+                        locale: "en",
+                        variants: [{ pattern: [{ type: "text", value: "Hello" }] }],
+                    },
+                    {
+                        locale: "de",
+                        variants: [{ pattern: [{ type: "text", value: "Hallo" }] }],
+                    },
+                    {
+                        locale: "fr",
+                        variants: [{ pattern: [{ type: "text", value: "Bonjour" }] }],
+                    },
+                ],
+            }));
+            await insertBundleNested(project.db, createBundleNested({
+                id: "farewell",
+                messages: [
+                    {
+                        locale: "en",
+                        variants: [{ pattern: [{ type: "text", value: "Goodbye" }] }],
+                    },
+                    {
+                        locale: "de",
+                        variants: [
+                            { pattern: [{ type: "text", value: "Auf Wiedersehen" }] },
+                        ],
+                    },
+                    {
+                        locale: "fr",
+                        variants: [{ pattern: [{ type: "text", value: "Au revoir" }] }],
+                    },
+                ],
+            }));
+            // Compile the project
+            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, runtime } = await importCode(code);
+            // Setup AsyncLocalStorage for tracking
+            runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+            // Test tracking in English
+            runtime.setLocale("en");
+            const messageCalls1 = new Set();
+            const result1 = await runtime.serverAsyncLocalStorage.run({ messageCalls: messageCalls1 }, () => {
+                const greeting = m.greeting();
+                const farewell = m.farewell();
+                expect(greeting).toBe("Hello");
+                expect(farewell).toBe("Goodbye");
+                return "english";
+            });
+            expect(result1).toBe("english");
+            expect(messageCalls1).toEqual(new Set(["greeting:en", "farewell:en"]));
+            // Test tracking in German
+            runtime.setLocale("de");
+            const messageCalls2 = new Set();
+            const result2 = await runtime.serverAsyncLocalStorage.run({ messageCalls: messageCalls2 }, () => {
+                const greeting = m.greeting();
+                expect(greeting).toBe("Hallo");
+                return "german";
+            });
+            expect(result2).toBe("german");
+            expect(messageCalls2).toEqual(new Set(["greeting:de"]));
+            expect(messageCalls2.has("farewell:de")).toBe(false);
+            // Test tracking with explicit locale
+            const messageCalls3 = new Set();
+            const result3 = await runtime.serverAsyncLocalStorage.run({ messageCalls: messageCalls3 }, () => {
+                const greeting = m.greeting(undefined, { locale: "fr" });
+                expect(greeting).toBe("Bonjour");
+                return "explicit";
+            });
+            expect(result3).toBe("explicit");
+            expect(messageCalls3).toEqual(new Set(["greeting:fr"]));
+            // Test nested tracking contexts
+            const messageCalls4 = new Set();
+            const result4 = await runtime.serverAsyncLocalStorage.run({ messageCalls: messageCalls4 }, () => {
+                // Access a message in the outer context
+                const outerGreeting = m.greeting();
+                expect(outerGreeting).toBe("Hallo"); // Still in German locale
+                // Create a nested tracking context
+                const nestedMessageCalls = new Set();
+                const nestedResult = runtime.serverAsyncLocalStorage.run({ messageCalls: nestedMessageCalls }, () => {
+                    // Access different messages in the nested context
+                    const nestedFarewell = m.farewell();
+                    expect(nestedFarewell).toBe("Auf Wiedersehen");
+                    return "nested";
+                });
+                // Verify nested tracking
+                expect(nestedResult).toBe("nested");
+                expect(nestedMessageCalls).toEqual(new Set(["farewell:de"]));
+                expect(nestedMessageCalls.has("greeting:de")).toBe(false); // Not accessed in nested context
+                return "outer";
+            });
+            // Verify outer context only contains its own calls
+            expect(result4).toBe("outer");
+            expect(messageCalls4).toEqual(new Set(["greeting:de"]));
+            // The farewell message should not be in the outer context
+            expect(messageCalls4.has("farewell:de")).toBe(false);
+        });
         test("arbitrary module identifiers work", async () => {
             const project = await loadProjectInMemory({
                 blob: await newProject({
@@ -434,6 +546,61 @@ describe.each([
             expect(m.missing_in_en_US()).toBe("Fallback message.");
         });
     });
+    test("case sensitivity handling for bundle IDs", async () => {
+        // skip local modules for now because the option might get removed in the future
+        if (compilerOptions.outputStructure === "locale-modules") {
+            return;
+        }
+        const project = await loadProjectInMemory({
+            blob: await newProject({
+                settings: { locales: ["en"], baseLocale: "en" },
+            }),
+        });
+        // Create two bundles with the same name but different case
+        await insertBundleNested(project.db, createBundleNested({
+            id: "Helloworld",
+            messages: [
+                {
+                    locale: "en",
+                    variants: [
+                        {
+                            pattern: [
+                                { type: "text", value: "Hello from uppercase bundle" },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        }));
+        await insertBundleNested(project.db, createBundleNested({
+            id: "helloworld",
+            messages: [
+                {
+                    locale: "en",
+                    variants: [
+                        {
+                            pattern: [
+                                { type: "text", value: "Hello from lowercase bundle" },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        }));
+        const output = await compileProject({
+            project,
+            compilerOptions,
+        });
+        const code = await bundleCode(output, `export * as m from "./paraglide/messages.js"
+				export { helloworld, Helloworld } from "./paraglide/messages.js"`);
+        const imported = await importCode(code);
+        // Both message functions should be available
+        expect(imported.helloworld()).toBe("Hello from lowercase bundle");
+        expect(imported.Helloworld()).toBe("Hello from uppercase bundle");
+        // They should also be available through the m namespace
+        expect(imported.m.helloworld()).toBe("Hello from lowercase bundle");
+        expect(imported.m.Helloworld()).toBe("Hello from uppercase bundle");
+    });
     // whatever the strictest users use, this is the ultimate nothing gets stricter than this
     // (to avoid developers opening issues "i get a ts warning in my code")
     const superStrictRuleOutAnyErrorTsSettings = {

package/dist/compiler/compiler-options.d.ts

@@ -5,6 +5,9 @@ export declare const defaultCompilerOptions: {
     readonly includeEslintDisableComment: true;
     readonly emitPrettierIgnore: true;
     readonly cleanOutdir: true;
+    readonly experimentalMiddlewareLocaleSplitting: false;
+    readonly localStorageKey: "PARAGLIDE_LOCALE";
+    readonly isServer: "typeof window === 'undefined'";
     readonly strategy: ["cookie", "globalVariable", "baseLocale"];
     readonly cookieName: "PARAGLIDE_LOCALE";
 };
@@ -49,6 +52,41 @@ export type CompilerOptions = {
      * @default ["url", "cookie", "variable", "baseLocale"]
      */
     strategy?: Runtime["strategy"];
+    /**
+     * Whether or not to use experimental middleware locale splitting.
+     *
+     * ⚠️ This feature is experimental and only works in SSR/SSG environment
+     *   without client-side routing. Do not rely on this feature for production.
+     *
+     * This feature is part of the exploration of per locale splitting. The
+     * issue is ongoing and can be followed here [#88](https://github.com/opral/inlang-paraglide-js/issues/88).
+     *
+     * - The client bundle will tree-shake all messages (have close to 0kb JS).
+     * - The server middleware will inject the used messages into the HTML.
+     * - The client will re-trieve the messages from the injected HTML.
+     *
+     * @default false
+     */
+    experimentalMiddlewareLocaleSplitting?: boolean;
+    /**
+     * The name of the localStorage key to use for the localStorage strategy.
+     *
+     * @default 'PARAGLIDE_LOCALE'
+     */
+    localStorageKey?: string;
+    /**
+     * Tree-shaking flag if the code is running on the server.
+     *
+     * Dependent on the bundler, this flag must be adapted to
+     * enable tree-shaking.
+     *
+     * @example
+     *   // vite
+     *   isServer: "import.meta.env.SSR"
+     *
+     * @default typeof window === "undefined"
+     */
+    isServer?: string;
     /**
      * The name of the cookie to use for the cookie strategy.
      *
@@ -96,7 +134,7 @@ export type CompilerOptions = {
      */
     emitPrettierIgnore?: boolean;
     /**
-     * TODO documentation
+     * https://inlang.com/m/gerre34r/library-inlang-paraglideJs/strategy#url
      */
     urlPatterns?: Runtime["urlPatterns"];
     /**

package/dist/compiler/compiler-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler-options.d.ts","sourceRoot":"","sources":["../../src/compiler/compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;;CAQU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,EAAE,CAAC,EAAE,GAAG,CAAC;CACT,CAAC"}
+{"version":3,"file":"compiler-options.d.ts","sourceRoot":"","sources":["../../src/compiler/compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;;;;;CAWU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;OAcG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;IAChD;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,EAAE,CAAC,EAAE,GAAG,CAAC;CACT,CAAC"}

package/dist/compiler/compiler-options.js

@@ -4,6 +4,9 @@ export const defaultCompilerOptions = {
     includeEslintDisableComment: true,
     emitPrettierIgnore: true,
     cleanOutdir: true,
+    experimentalMiddlewareLocaleSplitting: false,
+    localStorageKey: "PARAGLIDE_LOCALE",
+    isServer: "typeof window === 'undefined'",
     strategy: ["cookie", "globalVariable", "baseLocale"],
     cookieName: "PARAGLIDE_LOCALE",
 };

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

@@ -1,8 +1,5 @@
 import type { ProjectSettings } from "@inlang/sdk";
 import type { CompiledBundleWithMessages } from "../compile-bundle.js";
-import type { CompilerOptions } from "../compiler-options.js";
-export declare function generateLocaleModules(compiledBundles: CompiledBundleWithMessages[], settings: Pick<ProjectSettings, "locales" | "baseLocale">, fallbackMap: Record<string, string | undefined>, compilerOptions: {
-    strategy: NonNullable<CompilerOptions["strategy"]>;
-    cookieName: NonNullable<CompilerOptions["cookieName"]>;
-}): Record<string, string>;
+export declare function messageReferenceExpression(locale: string, bundleId: string): string;
+export declare function generateOutput(compiledBundles: CompiledBundleWithMessages[], settings: Pick<ProjectSettings, "locales" | "baseLocale">, fallbackMap: Record<string, string | undefined>): Record<string, string>;
 //# sourceMappingURL=locale-modules.d.ts.map

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;AAGvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAI9D,wBAAgB,qBAAqB,CACpC,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,EAC/C,eAAe,EAAE;IAChB,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;IACnD,UAAU,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;CACvD,GACC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA4DxB"}
+{"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"}