@inlang/paraglide-js 2.0.0-beta.15 → 2.0.0-beta.17

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;AAChD,OAAO,EAAW,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAOvE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,eAAe,CAiC3D,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;AAChD,OAAO,EAAW,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAYvE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,eAAe,CAwC3D,CAAC"}

package/dist/bundler-plugins/unplugin.js

@@ -2,15 +2,20 @@ import { compile } from "../compiler/compile.js";
 import fs from "node:fs";
 import { resolve } from "node:path";
 import { nodeNormalizePath } from "../utilities/node-normalize-path.js";
+import { Logger } from "../cli/index.js";
 const PLUGIN_NAME = "unplugin-paraglide-js";
+const logger = new Logger();
+let compilationResult;
 export const unpluginFactory = (args) => ({
     name: PLUGIN_NAME,
     enforce: "pre",
     async buildStart() {
-        await compile({
+        logger.info("Compiling inlang project...");
+        compilationResult = await compile({
             fs: wrappedFs,
             ...args,
         });
+        logger.success("Compilation complete");
         for (const path of Array.from(readFiles)) {
             this.addWatchFile(path);
         }
@@ -19,10 +24,12 @@ export const unpluginFactory = (args) => ({
         const shouldCompile = readFiles.has(path) && !path.includes("cache");
         if (shouldCompile) {
             readFiles.clear();
-            await compile({
+            logger.info(`Re-compiling inlang project... File "${path}" has changed.`);
+            compilationResult = await compile({
                 fs: wrappedFs,
                 ...args,
-            });
+            }, compilationResult?.outputHashes);
+            logger.success("Compilation complete");
         }
     },
     webpack(compiler) {

package/dist/cli/steps/run-compiler.js

@@ -8,6 +8,6 @@ export const runCompiler = async (ctx) => {
     const output = await compileProject({
         project: ctx.project,
     });
-    await writeOutput(absoluteOutdir, output, ctx.fs);
+    await writeOutput({ directory: absoluteOutdir, output, fs: ctx.fs });
     return { ...ctx };
 };

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,eAAe,CAAC;AAI9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAM3C,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,QAAQ,EAAE,QAAQ,CAAC;CACnB,KAAG,0BAgCH,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,eAAe,CAAC;AAI9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,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,QAAQ,EAAE,QAAQ,CAAC;CACnB,KAAG,0BAoCH,CAAC"}

package/dist/compiler/compile-bundle.js

@@ -2,20 +2,25 @@ import { compileMessage } from "./compile-message.js";
 import { jsIdentifier } from "../services/codegen/identifier.js";
 import { isValidJSIdentifier } from "../services/valid-js-identifier/index.js";
 import { escapeForDoubleQuoteString } from "../services/codegen/escape.js";
-import { jsDocBundleFunctionTypes, jsDocMessageFunctionTypes, } from "./jsdoc-types.js";
+import { jsDocBundleFunctionTypes } from "./jsdoc-types.js";
+import { KEYWORDS } from "../services/valid-js-identifier/reserved-words.js";
 /**
  * Compiles all the messages in the bundle and returns an index-function + each compiled message
  */
 export const compileBundle = (args) => {
     const compiledMessages = {};
+    if (KEYWORDS.includes(args.bundle.id) || args.bundle.id === "then") {
+        throw new Error([
+            `You are using a reserved JS keyword as id "${args.bundle.id}".`,
+            "Rename the message bundle id to something else.",
+            "See https://github.com/opral/inlang-paraglide-js/issues/331",
+        ].join("\n"));
+    }
     for (const message of args.bundle.messages) {
         if (compiledMessages[message.locale]) {
             throw new Error(`Duplicate locale: ${message.locale}`);
         }
         const compiledMessage = compileMessage(args.bundle.declarations, message, message.variants, args.registry);
-        // add types to the compiled message function
-        const inputs = args.bundle.declarations.filter((decl) => decl.type === "input-variable");
-        compiledMessage.code = `${jsDocMessageFunctionTypes({ inputs })}\n${compiledMessage.code}`;
         // set the pattern for the language tag
         compiledMessages[message.locale] = compiledMessage;
     }

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

@@ -57,3 +57,14 @@ const mockBundle = {
         },
     ],
 };
+test("throws if a JS keyword is used as an identifier", async () => {
+    expect(() => compileBundle({
+        fallbackMap: {},
+        registry: {},
+        bundle: {
+            id: "then",
+            declarations: [],
+            messages: [],
+        },
+    })).toThrow();
+});

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

@@ -4,9 +4,6 @@ import type { Compiled } from "./types.js";
 /**
  * Returns the compiled message as a string
  *
- * @example
- * @param message The message to compile
- * @returns (inputs) => string
  */
 export declare const compileMessage: (declarations: Declaration[], message: Message, variants: Variant[], registry: Registry) => Compiled<Message>;
 //# sourceMappingURL=compile-message.d.ts.map

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;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,iBACZ,WAAW,EAAE,WAClB,OAAO,YACN,OAAO,EAAE,YACT,QAAQ,KAChB,QAAQ,CAAC,OAAO,CAclB,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;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C;;;GAGG;AACH,eAAO,MAAM,cAAc,iBACZ,WAAW,EAAE,WAClB,OAAO,YACN,OAAO,EAAE,YACT,QAAQ,KAChB,QAAQ,CAAC,OAAO,CAelB,CAAC"}

package/dist/compiler/compile-message.js

@@ -1,11 +1,9 @@
 import { compilePattern } from "./compile-pattern.js";
 import { doubleQuote } from "../services/codegen/quotes.js";
+import { inputsType } from "./jsdoc-types.js";
 /**
  * Returns the compiled message as a string
  *
- * @example
- * @param message The message to compile
- * @returns (inputs) => string
  */
 export const compileMessage = (declarations, message, variants, registry) => {
     // return empty string instead?
@@ -15,20 +13,26 @@ export const compileMessage = (declarations, message, variants, registry) => {
     const hasMultipleVariants = variants.length > 1;
     return hasMultipleVariants
         ? compileMessageWithMultipleVariants(declarations, message, variants, registry)
-        : compileMessageWithOneVariant(message, variants, registry);
+        : compileMessageWithOneVariant(declarations, message, variants, registry);
 };
-function compileMessageWithOneVariant(message, variants, registry) {
+function compileMessageWithOneVariant(declarations, message, variants, registry) {
     const variant = variants[0];
     if (!variant || variants.length !== 1) {
         throw new Error("Message must have exactly one variant");
     }
+    const inputs = declarations.filter((decl) => decl.type === "input-variable");
+    const hasInputs = inputs.length > 0;
     const compiledPattern = compilePattern(message.locale, variant.pattern, registry);
-    const code = `export const ${message.bundleId} = (i) => ${compiledPattern.code}`;
+    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */
+export const ${message.bundleId} = (${hasInputs ? "i" : ""}) => ${compiledPattern.code};`;
     return { code, node: message };
 }
 function compileMessageWithMultipleVariants(declarations, message, variants, registry) {
-    if (variants.length <= 1)
+    if (variants.length <= 1) {
         throw new Error("Message must have more than one variant");
+    }
+    const inputs = declarations.filter((decl) => decl.type === "input-variable");
+    const hasInputs = inputs.length > 0;
     // TODO make sure that matchers use keys instead of indexes
     const compiledVariants = [];
     for (const variant of variants) {
@@ -56,8 +60,9 @@ function compileMessageWithMultipleVariants(declarations, message, variants, reg
             continue;
         compiledVariants.push(`if (${conditions.join(" && ")}) return ${compiledPattern.code};`);
     }
-    const code = `export const ${message.bundleId} = (i) => {
+    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */
+export const ${message.bundleId} = (${hasInputs ? "i" : ""}) => {
 	${compiledVariants.join("\n\t")}
-}`;
+};`;
     return { code, node: message };
 }

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

@@ -1,7 +1,7 @@
-import { it, expect } from "vitest";
+import { test, expect } from "vitest";
 import { compileMessage } from "./compile-message.js";
 import { DEFAULT_REGISTRY } from "./registry.js";
-it("compiles a message with a single variant", async () => {
+test("compiles a message with a single variant", async () => {
     const declarations = [];
     const message = {
         locale: "en",
@@ -21,7 +21,7 @@ it("compiles a message with a single variant", async () => {
     const { some_message } = await import("data:text/javascript;base64," + btoa(compiled.code));
     expect(some_message()).toBe("Hello");
 });
-it("compiles a message with variants", async () => {
+test("compiles a message with variants", async () => {
     const declarations = [
         { type: "input-variable", name: "fistInput" },
         { type: "input-variable", name: "secondInput" },
@@ -72,3 +72,25 @@ it("compiles a message with variants", async () => {
     expect(some_message({ fistInput: 3, secondInput: 4 })).toBe("Catch all");
     expect(some_message({ fistInput: 1, secondInput: 5 })).toBe("Catch all");
 });
+test("only emits input arguments when inputs exist", async () => {
+    const declarations = [];
+    const message = {
+        locale: "en",
+        bundleId: "some_message",
+        id: "message-id",
+        selectors: [],
+    };
+    const variants = [
+        {
+            id: "1",
+            messageId: "message-id",
+            matches: [],
+            pattern: [{ type: "text", value: "Hello" }],
+        },
+    ];
+    const compiled = compileMessage(declarations, message, variants, DEFAULT_REGISTRY);
+    expect(compiled.code, "single variant").toBe([
+        "/** @type {(inputs: {}) => string} */",
+        "export const some_message = () => `Hello`;",
+    ].join("\n"));
+});

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":"AAEA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAE5E;;;;;;;;;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,CAoEjC,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":"AAEA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAE5E;;;;;;;;;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,CAiEjC,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

@@ -49,9 +49,6 @@ export const compileProject = async (args) => {
         output[filename] = content;
     }
     for (const [filename, content] of Object.entries(output)) {
-        if (filename.endsWith(".js") || filename.endsWith(".ts")) {
-            output[filename] = `// @ts-nocheck\n${output[filename]}`;
-        }
         if (optionsWithDefaults.includeEslintDisableComment) {
             if (filename.endsWith(".js")) {
                 output[filename] = `// eslint-disable\n${content}`;

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

@@ -1,5 +1,5 @@
 import { expect, test, describe, vi, beforeEach } from "vitest";
-import { createProject as typescriptProject, ts } from "@ts-morph/bootstrap";
+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";
 import virtual from "@rollup/plugin-virtual";
@@ -63,15 +63,47 @@ test("emitPrettierIgnore", async () => {
     expect(_true).toHaveProperty(".prettierignore");
     expect(_false).not.toHaveProperty(".prettierignore");
 });
+// https://github.com/opral/inlang-paraglide-js/issues/347
+test("can emit message bundles with more than 255 characters", async () => {
+    const project = await loadProjectInMemory({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de"],
+            },
+        }),
+    });
+    await insertBundleNested(project.db, createBundleNested({
+        // 300 characters long id
+        id: "a".repeat(300),
+        messages: [
+            {
+                locale: "en",
+                variants: [
+                    {
+                        pattern: [{ type: "text", value: "Hello" }],
+                    },
+                ],
+            },
+        ],
+    }));
+    const output = await compileProject({
+        project,
+    });
+    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["a".repeat(300)]()).toBe("Hello");
+});
 describe.each([
     // useTsImports must be true to test emitTs. Otherwise, rolldown can't resolve the imports
     {
         outputStructure: "locale-modules",
-        strategy: ["variable", "baseLocale"],
+        strategy: ["globalVariable", "baseLocale"],
     },
     {
         outputStructure: "message-modules",
-        strategy: ["variable", "baseLocale"],
+        strategy: ["globalVariable", "baseLocale"],
     },
 ])("options", async (compilerOptions) => {
     const output = await compileProject({ project, compilerOptions });
@@ -79,7 +111,7 @@ describe.each([
         test("should tree-shake unused messages", async () => {
             const code = await bundleCode(output, `import * as m from "./paraglide/messages.js"
 
-			console.log(m.sad_penguin_bundle())`);
+					console.log(m.sad_penguin_bundle())`);
             const log = vi.spyOn(console, "log").mockImplementation(() => { });
             // all required code for the message to be rendered is included like sourceLanguageTag.
             // but, all other messages except of 'sad_penguin_bundle' are tree-shaken away.
@@ -275,70 +307,27 @@ describe.each([
             expect(m.missing_in_en_US()).toBe("Fallback message.");
         });
     });
-    // remove with v3 of paraglide js
-    test("./runtime.js types", async () => {
-        const project = await typescriptProject({
-            useInMemoryFileSystem: true,
-            compilerOptions: {
-                outDir: "dist",
-                declaration: true,
-                allowJs: true,
-                checkJs: true,
-                module: ts.ModuleKind.Node16,
-                strict: true,
-            },
-        });
-        console.log(output["runtime.js"]);
-        for (const [fileName, code] of Object.entries(output)) {
-            if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
-                project.createSourceFile(fileName, code);
-            }
-        }
-        project.createSourceFile("test.ts", `
-    import * as runtime from "./runtime.js"
-
-    // --------- RUNTIME ---------
-
-    // getLocale() should return type should be a union of language tags, not a generic string
-    runtime.getLocale() satisfies "de" | "en" | "en-US"
-
-    // locales should have a narrow type, not a generic string
-    runtime.locales satisfies Readonly<Array<"de" | "en" | "en-US">>
-
-    // setLocale() should fail if the given language tag is not included in locales
-    // @ts-expect-error - invalid locale
-    runtime.setLocale("fr")
-
-    // setLocale() should not fail if the given language tag is included in locales
-    runtime.setLocale("de")
-
-		// isLocale should narrow the type of it's argument
-		const thing = 5;
-		if(runtime.isLocale(thing)) {
-			const a : "de" | "en" | "en-US" = thing
-		} else {
-			// @ts-expect-error - thing is not a language tag
-			const a : "de" | "en" | "en-US" = thing
-		}
-  `);
-        const program = project.createProgram();
-        const diagnostics = ts.getPreEmitDiagnostics(program);
-        for (const diagnostic of diagnostics) {
-            console.error(diagnostic.messageText, diagnostic.file?.fileName);
-        }
-        expect(diagnostics.length).toEqual(0);
-    });
+    // 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 = {
+        outDir: "dist",
+        declaration: true,
+        allowJs: true,
+        checkJs: true,
+        noImplicitAny: true,
+        noUnusedLocals: true,
+        noUnusedParameters: true,
+        noImplicitReturns: true,
+        noImplicitThis: true,
+        noUncheckedIndexedAccess: true,
+        noPropertyAccessFromIndexSignature: true,
+        module: ts.ModuleKind.Node16,
+        strict: true,
+    };
     test("./messages.js types", async () => {
         const project = await typescriptProject({
             useInMemoryFileSystem: true,
-            compilerOptions: {
-                outDir: "dist",
-                declaration: true,
-                allowJs: true,
-                checkJs: true,
-                module: ts.ModuleKind.Node16,
-                strict: true,
-            },
+            compilerOptions: superStrictRuleOutAnyErrorTsSettings,
         });
         for (const [fileName, code] of Object.entries(output)) {
             if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
@@ -374,7 +363,10 @@ describe.each([
 		m.sad_penguin_bundle({}, { locale: "---" })
   `);
         const program = project.createProgram();
-        const diagnostics = ts.getPreEmitDiagnostics(program);
+        const diagnostics = ts
+            .getPreEmitDiagnostics(program)
+            // runtime type here makes issues because of the path-to-regexp import
+            .filter((d) => !d.file?.fileName.includes("runtime.js"));
         for (const diagnostic of diagnostics) {
             console.error(diagnostic.messageText, diagnostic.file?.fileName);
         }
@@ -382,6 +374,7 @@ describe.each([
     });
 });
 async function bundleCode(output, file) {
+    output["runtime.js"] = output["runtime.js"].replace('import * as pathToRegexp from "@inlang/paraglide-js/path-to-regexp";', "/** @type {any} */const pathToRegexp = {};");
     const bundle = await rolldown({
         input: ["main.js"],
         plugins: [

package/dist/compiler/compile.d.ts

@@ -4,7 +4,8 @@ export declare const defaultCompilerOptions: {
     readonly emitGitIgnore: true;
     readonly includeEslintDisableComment: true;
     readonly emitPrettierIgnore: true;
-    readonly strategy: ["cookie", "variable", "baseLocale"];
+    readonly pathnameBase: undefined;
+    readonly strategy: ["cookie", "globalVariable", "baseLocale"];
     readonly cookieName: "PARAGLIDE_LOCALE";
 };
 export type CompilerOptions = {
@@ -59,6 +60,42 @@ export type CompilerOptions = {
      * @default true
      */
     emitPrettierIgnore?: boolean;
+    /**
+     * The localized pathname patterns.
+     *
+     * The syntax is based on path-to-regexp v8
+     * https://github.com/pillarjs/path-to-regexp.
+     *
+     * @example
+     *   pathnames: {
+     *     "/about": {
+     *        "en": "/about",
+     *        "de": "/ueber-uns",
+     *     },
+     *     // catch all
+     *     "/{*path}": {
+     *       "de": "/de/{*path}",
+     *       "en": "/{*path}",
+     *     }
+     *   }
+     */
+    pathnames?: Record<string, Record<string, string>>;
+    /**
+     * The base path for the pathname strategy.
+     *
+     * If the pathnameBase is set, `localizePath()` and `deLocalizePath()` will
+     * automatically add or remove the base path from the pathname.
+     *
+     * Don't forget to set your server's or frameworks "base path" to the same value.
+     *
+     * @example
+     *   pathnameBase: "/base"
+     *
+     *   localizePath("/about") // -> "/base/about"
+     *
+     * @default undefined
+     */
+    pathnameBase?: string;
     /**
      * Whether to include an eslint-disable comment at the top of each .js file.
      *
@@ -97,5 +134,7 @@ export type CompilerOptions = {
  *     outdir: 'path/to/output',
  *   })
  */
-export declare function compile(options: CompilerOptions): Promise<void>;
+export declare function compile(options: CompilerOptions, previousOutputHashes?: Record<string, string>): Promise<{
+    outputHashes: Record<string, string> | undefined;
+}>;
 //# sourceMappingURL=compile.d.ts.map

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,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;CAOU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;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;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,EAAE,CAAC,EAAE,cAAc,SAAS,CAAC,CAAC;CAC9B,CAAC;AAMF;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA+CrE"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compiler/compile.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;;CAQU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;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;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,EAAE,CAAC,EAAE,cAAc,SAAS,CAAC,CAAC;CAC9B,CAAC;AAQF;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAC5B,OAAO,EAAE,eAAe,EACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3C,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;CAAE,CAAC,CAwD/D"}

package/dist/compiler/compile.js

@@ -9,7 +9,8 @@ export const defaultCompilerOptions = {
     emitGitIgnore: true,
     includeEslintDisableComment: true,
     emitPrettierIgnore: true,
-    strategy: ["cookie", "variable", "baseLocale"],
+    pathnameBase: undefined,
+    strategy: ["cookie", "globalVariable", "baseLocale"],
     cookieName: "PARAGLIDE_LOCALE",
 };
 // This is a workaround to prevent multiple compilations from running at the same time.
@@ -28,7 +29,7 @@ let compilationInProgress = null;
  *     outdir: 'path/to/output',
  *   })
  */
-export async function compile(options) {
+export async function compile(options, previousOutputHashes) {
     const withDefaultOptions = {
         ...defaultCompilerOptions,
         ...options,
@@ -50,7 +51,12 @@ export async function compile(options) {
             compilerOptions: withDefaultOptions,
             project,
         });
-        await writeOutput(absoluteOutdir, output, fs.promises);
+        const outputHashes = await writeOutput({
+            directory: absoluteOutdir,
+            output,
+            fs: fs.promises,
+            previousOutputHashes,
+        });
         if (!localAccount) {
             const activeAccount = await project.lix.db
                 .selectFrom("active_account")
@@ -59,7 +65,9 @@ export async function compile(options) {
             saveLocalAccount({ fs, account: activeAccount });
         }
         await project.close();
+        return { outputHashes };
     })();
-    await compilationInProgress;
+    const result = structuredClone(await compilationInProgress);
     compilationInProgress = null;
+    return result;
 }

package/dist/compiler/compile.test.js

@@ -79,7 +79,7 @@ test("saves the local account to app data if not exists", async () => {
     expect(account).toHaveProperty("id");
     expect(account).toHaveProperty("name");
 });
-test("cleans the output directory", async () => {
+test.skip("cleans the output directory", async () => {
     const fs = memfs().fs;
     const project = await loadProjectInMemory({
         blob: await newProject({}),
@@ -106,28 +106,50 @@ test("cleans the output directory", async () => {
 test("multiple compile calls do not interfere with each other", async () => {
     const fs = memfs().fs;
     const project = await loadProjectInMemory({
-        blob: await newProject({}),
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de", "fr"],
+            },
+        }),
     });
     await saveProjectToDirectory({
         project,
         path: "/project.inlang",
         fs: fs.promises,
     });
+    // different project settings to test compile output
+    await project.settings.set({
+        ...(await project.settings.get()),
+        baseLocale: "de",
+        locales: ["de"],
+    });
+    await saveProjectToDirectory({
+        project,
+        path: "/project2.inlang",
+        fs: fs.promises,
+    });
     const compilations = [
         compile({
             project: "/project.inlang",
-            outdir: "/output/subdir",
+            outdir: "/output",
             fs: fs,
         }),
         compile({
-            project: "/project.inlang",
+            project: "/project2.inlang",
             outdir: "/output",
             fs: fs,
         }),
     ];
     await Promise.all(compilations);
-    const outputDir = await fs.promises.readdir("/output");
-    expect(outputDir).not.toContain("subdir");
+    const runtimeFile = await fs.promises.readFile("/output/runtime.js", "utf8");
+    const runtime = (await import("data:text/javascript;base64," +
+        Buffer.from(
+        // replace the
+        runtimeFile.replace(`import * as pathToRegexp from "@inlang/paraglide-js/path-to-regexp";`, ""), "utf-8").toString("base64")));
+    // expecting the second compile step to overwrite the first
+    expect(runtime.baseLocale).toBe("de");
+    expect(runtime.locales).toEqual(["de"]);
 });
 test("emits additional files", async () => {
     const additionalFiles = {
@@ -199,5 +221,5 @@ test("default compiler options should include variable and baseLocale to ensure
     //
     // instead, make the apis work out of the box and once the developer is convinced that
     // paraglide js is the right tool for them, they can then define their own strategy.
-    expect(defaultCompilerOptions.strategy).toEqual(expect.arrayContaining(["variable", "baseLocale"]));
+    expect(defaultCompilerOptions.strategy).toEqual(expect.arrayContaining(["globalVariable", "baseLocale"]));
 });

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

@@ -3,7 +3,13 @@ export declare function jsDocBundleFunctionTypes(args: {
     inputs: InputVariable[];
     locales: string[];
 }): string;
-export declare function jsDocMessageFunctionTypes(args: {
-    inputs: InputVariable[];
-}): string;
+/**
+ * Returns the types for the input variables.
+ *
+ * @example
+ *   const inputs = [{ name: "age" }]
+ *   inputsType(inputs)
+ *   >> "{ age: NonNullable<unknown> }"
+ */
+export declare function inputsType(inputs: InputVariable[]): string;
 //# sourceMappingURL=jsdoc-types.d.ts.map

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,CAaT;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC/C,MAAM,EAAE,aAAa,EAAE,CAAC;CACxB,GAAG,MAAM,CAUT"}
+{"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"}