@inlang/paraglide-js 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/compiler/runtime/localize-url.js

@@ -1,38 +1,149 @@
-import { urlPatterns } from "./variables.js";
+import { extractLocaleFromUrl } from "./extract-locale-from-url.js";
+import { getLocale } from "./get-locale.js";
+import { getUrlOrigin } from "./get-url-origin.js";
+import { isLocale } from "./is-locale.js";
+import { baseLocale, TREE_SHAKE_DEFAULT_URL_PATTERN_USED, urlPatterns, } from "./variables.js";
 /**
- * Localizes a URL to a specific locale using the new namedGroups API.
- * @param {string | URL} url - The URL to localize.
- * @param {Object} options - Options containing the target locale.
- * @param {string} options.locale - The target locale.
- * @returns {URL} - The localized URL.
+ * Lower-level URL localization function, primarily used in server contexts.
+ *
+ * This function is designed for server-side usage where you need precise control
+ * over URL localization, such as in middleware or request handlers. It works with
+ * URL objects and always returns absolute URLs.
+ *
+ * For client-side UI components, use `localizeHref()` instead, which provides
+ * a more convenient API with relative paths and automatic locale detection.
+ *
+ * @example
+ * ```typescript
+ * // Server middleware example
+ * app.use((req, res, next) => {
+ *   const url = new URL(req.url, `${req.protocol}://${req.headers.host}`);
+ *   const localized = localizeUrl(url, { locale: "de" });
+ *
+ *   if (localized.href !== url.href) {
+ *     return res.redirect(localized.href);
+ *   }
+ *   next();
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with URL patterns
+ * const url = new URL("https://example.com/about");
+ * localizeUrl(url, { locale: "de" });
+ * // => URL("https://example.com/de/about")
+ *
+ * // Using with domain-based localization
+ * const url = new URL("https://example.com/store");
+ * localizeUrl(url, { locale: "de" });
+ * // => URL("https://de.example.com/store")
+ * ```
+ *
+ * @param {string | URL} url - The URL to localize. If string, must be absolute.
+ * @param {Object} [options] - Options for localization
+ * @param {string} [options.locale] - Target locale. If not provided, uses getLocale()
+ * @returns {URL} The localized URL, always absolute
  */
 export function localizeUrl(url, options) {
-    const urlObj = new URL(url);
+    if (TREE_SHAKE_DEFAULT_URL_PATTERN_USED) {
+        return localizeUrlDefaultPattern(url, options);
+    }
+    const locale = options?.locale ?? getLocale();
+    const urlObj = typeof url === "string" ? new URL(url) : url;
+    const search = urlObj.search;
     for (const element of urlPatterns) {
         const pattern = new URLPattern(element.pattern);
         const match = pattern.exec(urlObj.href);
         if (match) {
             /** @type {Record<string, string | null >} */
             const overrides = {};
-            for (const [groupName, value] of Object.entries(element.localizedNamedGroups?.[options.locale] ?? {})) {
+            for (const [groupName, value] of Object.entries(element.localizedNamedGroups?.[locale] ?? {})) {
                 overrides[groupName] = value;
             }
             const groups = {
                 ...aggregateGroups(match),
                 ...overrides,
             };
-            return fillPattern(element.pattern, groups);
+            return fillPattern(element.pattern, groups, search);
         }
     }
     throw new Error(`No match found for ${url}`);
 }
 /**
- * De-localizes a URL.
+ * https://github.com/opral/inlang-paraglide-js/issues/381
+ *
+ * @param {string | URL} url
+ * @param {Object} [options]
+ * @param {string} [options.locale]
+ * @returns {URL}
+ */
+function localizeUrlDefaultPattern(url, options) {
+    const urlObj = typeof url === "string" ? new URL(url, getUrlOrigin()) : new URL(url);
+    const locale = options?.locale ?? getLocale();
+    const currentLocale = extractLocaleFromUrl(urlObj);
+    // If current locale matches target locale, no change needed
+    if (currentLocale === locale) {
+        return urlObj;
+    }
+    const pathSegments = urlObj.pathname.split("/").filter(Boolean);
+    // If current path starts with a locale, remove it
+    if (pathSegments.length > 0 && isLocale(pathSegments[0])) {
+        pathSegments.shift();
+    }
+    // For base locale, don't add prefix
+    if (locale === baseLocale) {
+        urlObj.pathname = "/" + pathSegments.join("/");
+    }
+    else {
+        // For other locales, add prefix
+        urlObj.pathname = "/" + locale + "/" + pathSegments.join("/");
+    }
+    return urlObj;
+}
+/**
+ * Low-level URL de-localization function, primarily used in server contexts.
+ *
+ * This function is designed for server-side usage where you need precise control
+ * over URL de-localization, such as in middleware or request handlers. It works with
+ * URL objects and always returns absolute URLs.
+ *
+ * For client-side UI components, use `deLocalizeHref()` instead, which provides
+ * a more convenient API with relative paths.
+ *
+ * @example
+ * ```typescript
+ * // Server middleware example
+ * app.use((req, res, next) => {
+ *   const url = new URL(req.url, `${req.protocol}://${req.headers.host}`);
+ *   const baseUrl = deLocalizeUrl(url);
+ *
+ *   // Store the base URL for later use
+ *   req.baseUrl = baseUrl;
+ *   next();
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with URL patterns
+ * const url = new URL("https://example.com/de/about");
+ * deLocalizeUrl(url); // => URL("https://example.com/about")
  *
- * @type {(url: string | URL) => URL}
+ * // Using with domain-based localization
+ * const url = new URL("https://de.example.com/store");
+ * deLocalizeUrl(url); // => URL("https://example.com/store")
+ * ```
+ *
+ * @param {string | URL} url - The URL to de-localize. If string, must be absolute.
+ * @returns {URL} The de-localized URL, always absolute
  */
 export function deLocalizeUrl(url) {
-    const urlObj = new URL(url);
+    if (TREE_SHAKE_DEFAULT_URL_PATTERN_USED) {
+        return deLocalizeUrlDefaultPattern(url);
+    }
+    const urlObj = new URL(url, getUrlOrigin());
+    const search = urlObj.search;
     for (const element of urlPatterns) {
         const pattern = new URLPattern(element.pattern);
         const match = pattern.exec(urlObj.href);
@@ -46,11 +157,25 @@ export function deLocalizeUrl(url) {
                 ...aggregateGroups(match),
                 ...overrides,
             };
-            return fillPattern(element.pattern, groups);
+            return fillPattern(element.pattern, groups, search);
         }
     }
     throw new Error(`No match found for ${url}`);
 }
+/**
+ * De-localizes a URL using the default pattern (/:locale/*)
+ * @param {string|URL} url
+ * @returns {URL}
+ */
+function deLocalizeUrlDefaultPattern(url) {
+    const urlObj = typeof url === "string" ? new URL(url, getUrlOrigin()) : new URL(url);
+    const pathSegments = urlObj.pathname.split("/").filter(Boolean);
+    // If first segment is a locale, remove it
+    if (pathSegments.length > 0 && isLocale(pathSegments[0])) {
+        urlObj.pathname = "/" + pathSegments.slice(1).join("/");
+    }
+    return urlObj;
+}
 /**
  * Fills a URL pattern with values for named groups, supporting all URLPattern-style modifiers:
  *
@@ -67,9 +192,10 @@ export function deLocalizeUrl(url) {
  *
  * @param {string} pattern - The URL pattern containing named groups.
  * @param {Record<string, string | null | undefined>} values - Object of values for named groups.
+ * @param {string} [search] - Optional search (query) parameters to preserve
  * @returns {URL} - The constructed URL with named groups filled.
  */
-function fillPattern(pattern, values) {
+function fillPattern(pattern, values, search) {
     const filled = pattern.replace(/(\/?):([a-zA-Z0-9_]+)(\([^)]*\))?([?+*]?)/g, (_, slash, name, __, modifier) => {
         const value = values[name];
         if (value === null) {
@@ -93,13 +219,17 @@ function fillPattern(pattern, values) {
         }
         return `${slash}${value}`;
     });
-    return new URL(filled);
+    const url = new URL(filled);
+    if (search) {
+        url.search = search;
+    }
+    return url;
 }
 /**
  * Aggregates named groups from various parts of the URLPattern match result.
  *
  *
- * @type {(match: URLPatternResult) => Record<string, string | null | undefined>}
+ * @type {(match: any) => Record<string, string | null | undefined>}
  */
 export function aggregateGroups(match) {
     return {

package/dist/compiler/runtime/localize-url.test.js

@@ -202,3 +202,87 @@ test("localhost with portname", async () => {
     expect(runtime.deLocalizeUrl(new URL("http://localhost:5173/")).href).toBe("http://localhost:5173/");
     expect(runtime.deLocalizeUrl(new URL("https://localhost:5173/de")).href).toBe("https://localhost:5173/");
 });
+test("it keeps the query parameters", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["url"],
+            urlPatterns: [
+                {
+                    pattern: "https://:domain(.*)/:locale(de)?/:path*",
+                    deLocalizedNamedGroups: { locale: null },
+                    localizedNamedGroups: {
+                        en: { locale: null },
+                        de: { locale: "de" },
+                    },
+                },
+            ],
+        },
+    });
+    expect(runtime.localizeUrl("https://example.com/about?foo=bar&baz=qux", {
+        locale: "de",
+    }).href).toBe("https://example.com/de/about?foo=bar&baz=qux");
+    expect(runtime.deLocalizeUrl("https://example.com/de/about?foo=bar&baz=qux").href).toBe("https://example.com/about?foo=bar&baz=qux");
+});
+test("uses getLocale when no locale is provided", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["url"],
+            urlPatterns: [
+                {
+                    pattern: "https://:domain(.*)/:locale(de|en)?/:path(.*)?",
+                    deLocalizedNamedGroups: { locale: null },
+                    localizedNamedGroups: {
+                        en: { locale: "en" },
+                        de: { locale: "de" },
+                    },
+                },
+            ],
+        },
+    });
+    // Override getLocale to return German
+    runtime.overwriteGetLocale(() => "de");
+    expect(runtime.getLocale()).toBe("de");
+    // Should use "de" from getLocale since no locale provided
+    expect(runtime.localizeUrl("https://example.com/about").href).toBe("https://example.com/de/about");
+    // Should still use explicit locale when provided
+    expect(runtime.localizeUrl("https://example.com/about", { locale: "en" }).href).toBe("https://example.com/en/about");
+});
+// https://github.com/opral/inlang-paraglide-js/issues/381
+test.each([
+    // empty url pattern will set TREE_SHAKE_DEFAULT_ULR_PATTERN_USED to true
+    {},
+    // real default url pattern to align behaviour
+    {
+        urlPatterns: [
+            {
+                pattern: ":protocol://:domain(.*)::port?/:locale(de|fr)?/:path(.*)?",
+                deLocalizedNamedGroups: { locale: null },
+                localizedNamedGroups: {
+                    en: { locale: null },
+                    de: { locale: "de" },
+                    fr: { locale: "fr" },
+                },
+            },
+        ],
+    },
+])("default url pattern", async (compilerOptions) => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions,
+    });
+    runtime.overwriteGetLocale(() => "en");
+    expect(runtime.localizeUrl("https://example.com/about").href).toBe("https://example.com/about");
+    runtime.overwriteGetLocale(() => "de");
+    expect(runtime.localizeUrl("https://example.com/").href).toBe("https://example.com/de/");
+    expect(runtime.localizeUrl("https://example.com/about").href).toBe("https://example.com/de/about");
+    // Should still use explicit locale when provided
+    expect(runtime.localizeUrl("https://example.com/about", { locale: "de" }).href).toBe("https://example.com/de/about");
+    expect(runtime.localizeUrl("https://example.com/about", { locale: "en" }).href).toBe("https://example.com/about");
+    expect(runtime.deLocalizeUrl("https://example.com/de/about").href).toBe("https://example.com/about");
+    expect(runtime.deLocalizeUrl("https://example.com/about").href).toBe("https://example.com/about");
+});

package/dist/compiler/runtime/server-middleware.d.ts

@@ -18,7 +18,7 @@
  * @param {(args: { request: Request, locale: Locale }) => T | Promise<T>} resolve - Function to handle the request
  *
  * @returns {Promise<Response | any>} Returns either:
- * - A {@link Response} object (302 redirect) if URL localization is needed
+ * - A `Response` object (302 redirect) if URL localization is needed
  * - The result of the resolve function if no redirect is required
  *
  * @example
@@ -42,8 +42,6 @@
  *   });
  * });
  * ```
- *
- * @see {@link https://inlang.com/documentation/paraglide-js/server-middleware|Server Middleware Documentation}
  */
 export function serverMiddleware<T>(request: Request, resolve: (args: {
     request: Request;

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

@@ -1 +1 @@
-{"version":3,"file":"server-middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/server-middleware.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,iCAjCa,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAE5D,OAAO,CAAC,QAAQ,GAAG,GAAG,CAAC,CA2DnC"}
+{"version":3,"file":"server-middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/server-middleware.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,iCA/Ba,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAE5D,OAAO,CAAC,QAAQ,GAAG,GAAG,CAAC,CAyDnC"}

package/dist/compiler/runtime/server-middleware.js

@@ -32,7 +32,7 @@ let serverMiddlewareAsyncStorage = undefined;
  * @param {(args: { request: Request, locale: Locale }) => T | Promise<T>} resolve - Function to handle the request
  *
  * @returns {Promise<Response | any>} Returns either:
- * - A {@link Response} object (302 redirect) if URL localization is needed
+ * - A `Response` object (302 redirect) if URL localization is needed
  * - The result of the resolve function if no redirect is required
  *
  * @example
@@ -56,8 +56,6 @@ let serverMiddlewareAsyncStorage = undefined;
  *   });
  * });
  * ```
- *
- * @see {@link https://inlang.com/documentation/paraglide-js/server-middleware|Server Middleware Documentation}
  */
 export async function serverMiddleware(request, resolve) {
     if (!serverMiddlewareAsyncStorage) {

package/dist/compiler/runtime/variables.d.ts

@@ -36,4 +36,5 @@ export const TREE_SHAKE_COOKIE_STRATEGY_USED: false;
 export const TREE_SHAKE_URL_STRATEGY_USED: false;
 export const TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED: false;
 export const TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED: false;
+export const TREE_SHAKE_DEFAULT_URL_PATTERN_USED: false;
 //# sourceMappingURL=variables.d.ts.map

package/dist/compiler/runtime/variables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/variables.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,yBAA0B,IAAI,CAAC;AAE/B;;;;;;;GAOG;AACH,4CAA2D;AAE3D,qBAAqB;AACrB,yBADW,MAAM,CACyB;AAE1C;;GAEG;AACH,uBAFU,KAAK,CAAC,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,KAAK,GAAG,mBAAmB,CAAC,CAE9C;AAE3C;;;;GAIG;AACH,0BAFU,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAA;CAAE,CAAC,CAElI;AAE9B,8CAA+C,KAAK,CAAC;AAErD,2CAA4C,KAAK,CAAC;AAElD,uDAAwD,KAAK,CAAC;AAE9D,0DAA2D,KAAK,CAAC"}
+{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/variables.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,yBAA0B,IAAI,CAAC;AAE/B;;;;;;;GAOG;AACH,4CAA2D;AAE3D,qBAAqB;AACrB,yBADW,MAAM,CACyB;AAE1C;;GAEG;AACH,uBAFU,KAAK,CAAC,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,KAAK,GAAG,mBAAmB,CAAC,CAE9C;AAE3C;;;;GAIG;AACH,0BAFU,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAA;CAAE,CAAC,CAElI;AAE9B,8CAA+C,KAAK,CAAC;AAErD,2CAA4C,KAAK,CAAC;AAElD,uDAAwD,KAAK,CAAC;AAE9D,0DAA2D,KAAK,CAAC;AAEjE,kDAAmD,KAAK,CAAC"}

package/dist/compiler/runtime/variables.js

@@ -32,3 +32,4 @@ export const TREE_SHAKE_COOKIE_STRATEGY_USED = false;
 export const TREE_SHAKE_URL_STRATEGY_USED = false;
 export const TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED = false;
 export const TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED = false;
+export const TREE_SHAKE_DEFAULT_URL_PATTERN_USED = false;

package/dist/compiler/safe-module-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Turns an unsafe module id like `helloWorld🍌` into a safe one like `helloworld__`.
+ *
+ * Mainly exists to support https://github.com/opral/inlang-paraglide-js/issues/285
+ */
+export declare function toSafeModuleId(id: string): string;
+export declare function isSafeModuleId(id: string): boolean;
+//# sourceMappingURL=safe-module-id.d.ts.map

package/dist/compiler/safe-module-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-module-id.d.ts","sourceRoot":"","sources":["../../src/compiler/safe-module-id.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAYjD;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAElD"}

package/dist/compiler/safe-module-id.js

@@ -0,0 +1,71 @@
+/**
+ * Turns an unsafe module id like `helloWorld🍌` into a safe one like `helloworld__`.
+ *
+ * Mainly exists to support https://github.com/opral/inlang-paraglide-js/issues/285
+ */
+export function toSafeModuleId(id) {
+    const result = id.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+    const startsWithNumber = result[0]?.match(/[0-9]/);
+    if (startsWithNumber) {
+        return "_" + result;
+    }
+    else if (reservedJsKeywords.includes(result)) {
+        return "_" + result;
+    }
+    return result;
+}
+export function isSafeModuleId(id) {
+    return toSafeModuleId(id) === id;
+}
+const reservedJsKeywords = [
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    //Strict mode reserved keywords
+    "let",
+    "static",
+    "yield",
+    "await",
+    //Reserved keywords for future use
+    "enum",
+    "implements",
+    "interface",
+    "package",
+    "private",
+    "protected",
+    "public",
+    // https://github.com/opral/inlang-paraglide-js/issues/331
+    "then",
+];

package/dist/compiler/safe-module-id.test.d.ts

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

package/dist/compiler/safe-module-id.test.d.ts.map

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

package/dist/compiler/safe-module-id.test.js

@@ -0,0 +1,27 @@
+import { test, expect } from "vitest";
+import { toSafeModuleId } from "./safe-module-id.js";
+test("handles emojis (because why not)", () => {
+    expect(toSafeModuleId("helloWorld🍌")).toBe("helloworld__");
+});
+// https://github.com/opral/inlang-paraglide-js/issues/395
+test("makes everything lowercase", () => {
+    expect(toSafeModuleId("HelloWorld")).toBe("helloworld");
+});
+test('escapes "-" to "_"', () => {
+    expect(toSafeModuleId("de-DE-bavaria")).toBe("de_de_bavaria");
+});
+test("prefixes with _ if it starts with a number", () => {
+    expect(toSafeModuleId("123")).toBe("_123");
+});
+test("handles $ signs", () => {
+    expect(toSafeModuleId("default_e$")).toBe("default_e_");
+});
+test("handles . dots", () => {
+    expect(toSafeModuleId("hello.world.nested")).toBe("hello_world_nested");
+});
+test("transforms js reserved keywords", async () => {
+    expect(toSafeModuleId("import")).toBe("_import");
+    expect(toSafeModuleId("let")).toBe("_let");
+    // https://github.com/opral/inlang-paraglide-js/issues/331
+    expect(toSafeModuleId("then")).toBe("_then");
+});

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.0-beta.19",
+    PARJS_PACKAGE_VERSION: "2.0.0-beta.21",
 };

package/dist/services/file-handling/write-output.d.ts

@@ -4,5 +4,5 @@ export declare function writeOutput(args: {
     output: Record<string, string>;
     fs: typeof nodeFs;
     previousOutputHashes?: Record<string, string>;
-}): Promise<Record<string, string> | undefined>;
+}): Promise<Record<string, string>>;
 //# sourceMappingURL=write-output.d.ts.map

package/dist/services/file-handling/write-output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write-output.d.ts","sourceRoot":"","sources":["../../../src/services/file-handling/write-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAE3C,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,EAAE,EAAE,OAAO,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C,+CA4CA"}
+{"version":3,"file":"write-output.d.ts","sourceRoot":"","sources":["../../../src/services/file-handling/write-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAE3C,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,EAAE,EAAE,OAAO,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C,mCA4CA"}

package/dist/services/file-handling/write-output.js

@@ -10,7 +10,7 @@ export async function writeOutput(args) {
         }
     }
     if (changedFiles.size === 0) {
-        return;
+        return currentOutputHashes;
     }
     // disabled because of https://github.com/opral/inlang-paraglide-js/issues/350
     // // clear the output directory

package/dist/services/file-handling/write-output.test.js

@@ -51,12 +51,13 @@ it("should only write once if the output hasn't changed", async () => {
         output: { "test.txt": "test" },
         fs,
     });
-    await writeOutput({
+    const hashes2 = await writeOutput({
         directory: "/output",
         output: { "test.txt": "test" },
         fs,
         previousOutputHashes: hashes,
     });
+    expect(hashes).toEqual(hashes2);
     expect(await fs.readFile("/output/test.txt", { encoding: "utf-8" })).toBe("test");
     expect(fs.writeFile).toHaveBeenCalledTimes(1);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.0.0-beta.20",
+  "version": "2.0.0-beta.21",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -49,9 +49,9 @@
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.20.0",
     "vitest": "2.1.8",
-    "@inlang/paraglide-js": "2.0.0-beta.20",
+    "@inlang/paraglide-js": "2.0.0-beta.21",
     "@opral/tsconfig": "1.1.0",
-    "@inlang/plugin-message-format": "3.2.1"
+    "@inlang/plugin-message-format": "4.0.0"
   },
   "keywords": [
     "inlang",