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

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

@@ -37,3 +37,51 @@ test("should emit per locale message files", () => {
     expect(output).toHaveProperty("messages/happy_elephant/de.js");
     expect(output).toHaveProperty("messages/happy_elephant/index.js");
 });
+test("handles case senstivity by creating directories and files only in lowercase", () => {
+    const resources = [
+        {
+            bundle: {
+                code: "export const HappyElephant = () => en.HappyElephant",
+                node: {
+                    id: "HappyElephant",
+                },
+            },
+            messages: {
+                en: {
+                    code: 'export const HappyElephant = () => "HappyElephant0"',
+                    node: {},
+                },
+            },
+        },
+        {
+            bundle: {
+                code: "export const happyelephant = () => en.happyelephant",
+                node: {
+                    id: "happyelephant",
+                },
+            },
+            messages: {
+                en: {
+                    code: 'export const happyelephant = () => "happyelephant1"',
+                    node: {},
+                },
+            },
+        },
+    ];
+    const settings = {
+        locales: ["en"],
+        baseLocale: "en",
+    };
+    const output = generateMessageModules(resources, settings, {}, defaultCompilerOptions);
+    // expecting only lowercase directories and files
+    expect(output).toHaveProperty("messages/happyelephant/en.js");
+    expect(output).toHaveProperty("messages/happyelephant/index.js");
+    expect(output).not.toHaveProperty("messages/HappyElephant/en.js");
+    expect(output).not.toHaveProperty("messages/HappyElephant/index.js");
+    // expecting both bundles to be merged into the "happyelephant" module
+    expect(output["messages/happyelephant/index.js"]).includes(`export const happyelephant = () => en.happyelephant`);
+    expect(output["messages/happyelephant/index.js"]).includes(`export const HappyElephant = () => en.HappyElephant`);
+    // expecting both messages to be in their respective files
+    expect(output["messages/happyelephant/en.js"]).includes(`export const HappyElephant = () => "HappyElephant0"`);
+    expect(output["messages/happyelephant/en.js"]).includes(`export const HappyElephant = () => "HappyElephant0"`);
+});

package/dist/compiler/runtime/create-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/create-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,wBAAwB,CAAC;AAEhC;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,EAAE;QAChB,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;QACnD,UAAU,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;QACvD,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;KAC7C,CAAC;CACF,GAAG,MAAM,CA0FT;AAkBD;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,CAAC;CACrE,GAAG,OAAO,CAAC,OAAO,CAAC,CAkBnB"}
+{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/create-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,wBAAwB,CAAC;AAEhC;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,EAAE;QAChB,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;QACnD,UAAU,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;QACvD,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;KAC7C,CAAC;CACF,GAAG,MAAM,CAiGT;AAkBD;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,CAAC;CACrE,GAAG,OAAO,CAAC,OAAO,CAAC,CAkBnB"}

package/dist/compiler/runtime/create-runtime.js

@@ -5,8 +5,10 @@ import { defaultCompilerOptions, } from "../compiler-options.js";
  */
 export function createRuntimeFile(args) {
     const urlPatterns = args.compilerOptions.urlPatterns ?? [];
+    let defaultUrlPatternUsed = false;
     // add default urlPatterns for a good out of the box experience
     if (args.compilerOptions.urlPatterns === undefined) {
+        defaultUrlPatternUsed = true;
         urlPatterns.push({
             pattern: `:protocol://:domain(.*)::port?/:locale(${args.locales.filter((l) => l !== args.baseLocale).join("|")})?/:path(.*)?`,
             deLocalizedNamedGroups: { locale: null },
@@ -17,18 +19,19 @@ export function createRuntimeFile(args) {
         });
     }
     const code = `
-import "@inlang/paraglide-js/urlpattern-polyfill";
+${defaultUrlPatternUsed ? "/** @type {any} */\nconst URLPattern = {}" : `import "@inlang/paraglide-js/urlpattern-polyfill";`}
 
 ${injectCode("./variables.js")
         .replace(`export const baseLocale = "en";`, `export const baseLocale = "${args.baseLocale}";`)
         .replace(`export const locales = /** @type {const} */ (["en", "de"]);`, `export const locales = /** @type {const} */ (["${args.locales.join('", "')}"]);`)
-        .replace(`export const strategy = ["globalVariable"];`, `export const strategy = ["${args.compilerOptions.strategy.join('", "')}"]`)
+        .replace(`export const strategy = ["globalVariable"];`, `export const strategy = ${JSON.stringify(args.compilerOptions.strategy, null, 2)};`)
         .replace(`<cookie-name>`, `${args.compilerOptions.cookieName}`)
         .replace(`export const TREE_SHAKE_COOKIE_STRATEGY_USED = false;`, `const TREE_SHAKE_COOKIE_STRATEGY_USED = ${args.compilerOptions.strategy.includes("cookie")};`)
         .replace(`export const TREE_SHAKE_URL_STRATEGY_USED = false;`, `const TREE_SHAKE_URL_STRATEGY_USED = ${args.compilerOptions.strategy.includes("url")};`)
         .replace(`export const TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED = false;`, `const TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED = ${args.compilerOptions.strategy.includes("globalVariable")};`)
         .replace(`export const TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED = false;`, `const TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED = ${args.compilerOptions.strategy.includes("preferredLanguage")};`)
-        .replace(`export const urlPatterns = [];`, `export const urlPatterns = ${JSON.stringify(urlPatterns, null, 2)};`)}
+        .replace(`export const urlPatterns = [];`, `export const urlPatterns = ${JSON.stringify(urlPatterns, null, 2)};`)
+        .replace(`export const TREE_SHAKE_DEFAULT_URL_PATTERN_USED = false;`, `const TREE_SHAKE_DEFAULT_URL_PATTERN_USED = ${defaultUrlPatternUsed};`)}
 
 ${injectCode("./get-locale.js")} 
 

package/dist/compiler/runtime/extract-locale-from-url.d.ts

@@ -1,8 +1,8 @@
 /**
  * Extracts the locale from a given URL using native URLPattern.
  *
- * @param {string} url - The full URL from which to extract the locale.
+ * @param {URL|string} url - The full URL from which to extract the locale.
  * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
  */
-export function extractLocaleFromUrl(url: string): Locale | undefined;
+export function extractLocaleFromUrl(url: URL | string): Locale | undefined;
 //# sourceMappingURL=extract-locale-from-url.d.ts.map

package/dist/compiler/runtime/extract-locale-from-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract-locale-from-url.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-url.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,0CAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CA+C5B"}
+{"version":3,"file":"extract-locale-from-url.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-url.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,0CAHW,GAAG,GAAC,MAAM,GACR,MAAM,GAAC,SAAS,CAkD5B"}

package/dist/compiler/runtime/extract-locale-from-url.js

@@ -1,13 +1,17 @@
 import { assertIsLocale } from "./assert-is-locale.js";
+import { isLocale } from "./is-locale.js";
 import { aggregateGroups } from "./localize-url.js";
-import { urlPatterns } from "./variables.js";
+import { baseLocale, TREE_SHAKE_DEFAULT_URL_PATTERN_USED, urlPatterns, } from "./variables.js";
 /**
  * Extracts the locale from a given URL using native URLPattern.
  *
- * @param {string} url - The full URL from which to extract the locale.
+ * @param {URL|string} url - The full URL from which to extract the locale.
  * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
  */
 export function extractLocaleFromUrl(url) {
+    if (TREE_SHAKE_DEFAULT_URL_PATTERN_USED) {
+        return defaultUrlPatternExtractLocale(url);
+    }
     for (const element of urlPatterns) {
         const pattern = new URLPattern(element.pattern);
         const match = pattern.exec(url);
@@ -46,3 +50,21 @@ export function extractLocaleFromUrl(url) {
     }
     return undefined;
 }
+/**
+ * https://github.com/opral/inlang-paraglide-js/issues/381
+ *
+ * @param {URL|string} url - The full URL from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+function defaultUrlPatternExtractLocale(url) {
+    const urlObj = new URL(url, "http://dummy.com");
+    const pathSegments = urlObj.pathname.split("/").filter(Boolean);
+    if (pathSegments.length > 0) {
+        const potentialLocale = pathSegments[0];
+        if (isLocale(potentialLocale)) {
+            return potentialLocale;
+        }
+    }
+    // everything else has to be the base locale
+    return baseLocale;
+}

package/dist/compiler/runtime/extract-locale-from-url.test.js

@@ -87,3 +87,15 @@ test("regex works", async () => {
     expect(extractLocaleFromUrl(`https://example.com/de/subpage`)).toBe("de");
     expect(extractLocaleFromUrl(`https://example.com/subpage`)).toBe("en");
 });
+test("default url pattern", async () => {
+    const r = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+    });
+    expect(r.extractLocaleFromUrl("https://example.com/")).toBe("en");
+    expect(r.extractLocaleFromUrl("https://example.com/de")).toBe("de");
+    // anyhing other than a valid locale must be the base locale
+    expect(r.extractLocaleFromUrl("https://example.com/fr")).toBe("en");
+    expect(r.extractLocaleFromUrl("https://example.com/optional-subpage")).toBe("en");
+    expect(r.extractLocaleFromUrl("https://example.com/de/optional-subpage")).toBe("de");
+});

package/dist/compiler/runtime/localize-href.d.ts

@@ -1,46 +1,82 @@
 /**
- * Localizes an href.
+ * High-level URL localization function optimized for client-side UI usage.
  *
- * In contrast to `localizeUrl()`, this function automatically
- * calls `getLocale()` to determine the target locale and
- * returns a relative path if appropriate.
+ * This is a convenience wrapper around `localizeUrl()` that provides features
+ * needed in UI:
+ *
+ * - Accepts relative paths (e.g., "/about")
+ * - Returns relative paths when possible
+ * - Automatically detects current locale if not specified
+ * - Handles string input/output instead of URL objects
  *
  * @example
- *   localizeHref("/about")
- *   // => "/de/about"
+ * ```typescript
+ * // In a React/Vue/Svelte component
+ * const NavLink = ({ href }) => {
+ *   // Automatically uses current locale, keeps path relative
+ *   return <a href={localizeHref(href)}>...</a>;
+ * };
+ *
+ * // Examples:
+ * localizeHref("/about")
+ * // => "/de/about" (if current locale is "de")
+ * localizeHref("/store", { locale: "fr" })
+ * // => "/fr/store" (explicit locale)
  *
- *   // requires full URL and locale
- *   localizeUrl("http://example.com/about", { locale: "de" })
- *   // => "http://example.com/de/about"
+ * // Cross-origin links remain absolute
+ * localizeHref("https://other-site.com/about")
+ * // => "https://other-site.com/de/about"
+ * ```
  *
- * @param {string} href
- * @param {Object} [options] - Options
- * @param {string} [options.locale] - The target locale.
+ * For server-side URL localization (e.g., in middleware), use `localizeUrl()`
+ * which provides more precise control over URL handling.
+ *
+ * @param {string} href - The href to localize (can be relative or absolute)
+ * @param {Object} [options] - Options for localization
+ * @param {string} [options.locale] - Target locale. If not provided, uses `getLocale()`
+ * @returns {string} The localized href, relative if input was relative
  */
 export function localizeHref(href: string, options?: {
     locale?: string | undefined;
 }): string;
 /**
- * De-localizes an href.
+ * High-level URL de-localization function optimized for client-side UI usage.
+ *
+ * This is a convenience wrapper around `deLocalizeUrl()` that provides features
+ * needed in the UI:
  *
- * In contrast to `deLocalizeUrl()`, this function automatically
- * calls `getLocale()` to determine the base locale and
- * returns a relative path if appropriate.
+ * - Accepts relative paths (e.g., "/de/about")
+ * - Returns relative paths when possible
+ * - Handles string input/output instead of URL objects
  *
  * @example
- *   deLocalizeHref("/de/about")
- *   // => "/about"
+ * ```typescript
+ * // In a React/Vue/Svelte component
+ * const LocaleSwitcher = ({ href }) => {
+ *   // Remove locale prefix before switching
+ *   const baseHref = deLocalizeHref(href);
+ *   return locales.map(locale =>
+ *     <a href={localizeHref(baseHref, { locale })}>
+ *       Switch to {locale}
+ *     </a>
+ *   );
+ * };
  *
- *   // requires full URL and locale
- *   deLocalizeUrl("http://example.com/de/about")
- *   // => "http://example.com/about"
+ * // Examples:
+ * deLocalizeHref("/de/about")  // => "/about"
+ * deLocalizeHref("/fr/store")  // => "/store"
  *
- * @param {string} href
- * @returns {string} - The de-localized href.
+ * // Cross-origin links remain absolute
+ * deLocalizeHref("https://example.com/de/about")
+ * // => "https://example.com/about"
+ * ```
+ *
+ * For server-side URL de-localization (e.g., in middleware), use `deLocalizeUrl()`
+ * which provides more precise control over URL handling.
+ *
+ * @param {string} href - The href to de-localize (can be relative or absolute)
+ * @returns {string} The de-localized href, relative if input was relative
+ * @see deLocalizeUrl - For low-level URL de-localization in server contexts
  */
 export function deLocalizeHref(href: string): string;
-export function localizePath(href: string, options?: {
-    locale?: string;
-}): string;
-export function deLocalizePath(href: string): string;
 //# sourceMappingURL=localize-href.d.ts.map

package/dist/compiler/runtime/localize-href.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localize-href.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-href.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,mCAJW,MAAM,YAEd;IAAyB,MAAM;CACjC,UAqBA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qCAHW,MAAM,GACJ,MAAM,CAclB;AAIS,mCAAO,MAAM,YAAY;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAK,MAAM,CAAA;AAQvD,qCAAO,MAAM,GAAK,MAAM,CAAA"}
+{"version":3,"file":"localize-href.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-href.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,mCALW,MAAM,YAEd;IAAyB,MAAM;CAC/B,GAAU,MAAM,CAsBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qCAJW,MAAM,GACJ,MAAM,CAelB"}

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

@@ -2,28 +2,47 @@ import { getLocale } from "./get-locale.js";
 import { getUrlOrigin } from "./get-url-origin.js";
 import { deLocalizeUrl, localizeUrl } from "./localize-url.js";
 /**
- * Localizes an href.
+ * High-level URL localization function optimized for client-side UI usage.
  *
- * In contrast to `localizeUrl()`, this function automatically
- * calls `getLocale()` to determine the target locale and
- * returns a relative path if appropriate.
+ * This is a convenience wrapper around `localizeUrl()` that provides features
+ * needed in UI:
+ *
+ * - Accepts relative paths (e.g., "/about")
+ * - Returns relative paths when possible
+ * - Automatically detects current locale if not specified
+ * - Handles string input/output instead of URL objects
  *
  * @example
- *   localizeHref("/about")
- *   // => "/de/about"
+ * ```typescript
+ * // In a React/Vue/Svelte component
+ * const NavLink = ({ href }) => {
+ *   // Automatically uses current locale, keeps path relative
+ *   return <a href={localizeHref(href)}>...</a>;
+ * };
+ *
+ * // Examples:
+ * localizeHref("/about")
+ * // => "/de/about" (if current locale is "de")
+ * localizeHref("/store", { locale: "fr" })
+ * // => "/fr/store" (explicit locale)
+ *
+ * // Cross-origin links remain absolute
+ * localizeHref("https://other-site.com/about")
+ * // => "https://other-site.com/de/about"
+ * ```
  *
- *   // requires full URL and locale
- *   localizeUrl("http://example.com/about", { locale: "de" })
- *   // => "http://example.com/de/about"
+ * For server-side URL localization (e.g., in middleware), use `localizeUrl()`
+ * which provides more precise control over URL handling.
  *
- * @param {string} href
- * @param {Object} [options] - Options
- * @param {string} [options.locale] - The target locale.
+ * @param {string} href - The href to localize (can be relative or absolute)
+ * @param {Object} [options] - Options for localization
+ * @param {string} [options.locale] - Target locale. If not provided, uses `getLocale()`
+ * @returns {string} The localized href, relative if input was relative
  */
 export function localizeHref(href, options) {
     const locale = options?.locale ?? getLocale();
     const url = new URL(href, getUrlOrigin());
-    const localized = localizeUrl(url, { locale });
+    const localized = localizeUrl(url, options);
     // if the origin is identical and the href is relative,
     // return the relative path
     if (href.startsWith("/") && url.origin === localized.origin) {
@@ -39,22 +58,43 @@ export function localizeHref(href, options) {
     return localized.href;
 }
 /**
- * De-localizes an href.
+ * High-level URL de-localization function optimized for client-side UI usage.
  *
- * In contrast to `deLocalizeUrl()`, this function automatically
- * calls `getLocale()` to determine the base locale and
- * returns a relative path if appropriate.
+ * This is a convenience wrapper around `deLocalizeUrl()` that provides features
+ * needed in the UI:
+ *
+ * - Accepts relative paths (e.g., "/de/about")
+ * - Returns relative paths when possible
+ * - Handles string input/output instead of URL objects
  *
  * @example
- *   deLocalizeHref("/de/about")
- *   // => "/about"
+ * ```typescript
+ * // In a React/Vue/Svelte component
+ * const LocaleSwitcher = ({ href }) => {
+ *   // Remove locale prefix before switching
+ *   const baseHref = deLocalizeHref(href);
+ *   return locales.map(locale =>
+ *     <a href={localizeHref(baseHref, { locale })}>
+ *       Switch to {locale}
+ *     </a>
+ *   );
+ * };
+ *
+ * // Examples:
+ * deLocalizeHref("/de/about")  // => "/about"
+ * deLocalizeHref("/fr/store")  // => "/store"
+ *
+ * // Cross-origin links remain absolute
+ * deLocalizeHref("https://example.com/de/about")
+ * // => "https://example.com/about"
+ * ```
  *
- *   // requires full URL and locale
- *   deLocalizeUrl("http://example.com/de/about")
- *   // => "http://example.com/about"
+ * For server-side URL de-localization (e.g., in middleware), use `deLocalizeUrl()`
+ * which provides more precise control over URL handling.
  *
- * @param {string} href
- * @returns {string} - The de-localized href.
+ * @param {string} href - The href to de-localize (can be relative or absolute)
+ * @returns {string} The de-localized href, relative if input was relative
+ * @see deLocalizeUrl - For low-level URL de-localization in server contexts
  */
 export function deLocalizeHref(href) {
     const url = new URL(href, getUrlOrigin());
@@ -66,17 +106,3 @@ export function deLocalizeHref(href) {
     }
     return deLocalized.href;
 }
-/**
- * @deprecated use `localizeHref` instead and give feedback on here https://github.com/opral/inlang-paraglide-js/issues/380
- * @type {(href: string, options?: { locale?: string }) => string}
- */
-export function localizePath(href, options) {
-    return localizeHref(href, options);
-}
-/**
- * @deprecated use `deLocalizeHref` instead and give feedback on here https://github.com/opral/inlang-paraglide-js/issues/380
- * @type {(href: string) => string}
- */
-export function deLocalizePath(href) {
-    return deLocalizeHref(href);
-}

package/dist/compiler/runtime/localize-url.d.ts

@@ -1,13 +1,85 @@
 /**
- * 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: string | URL, options: {
-    locale: string;
+export function localizeUrl(url: string | URL, options?: {
+    locale?: string | undefined;
 }): URL;
+/**
+ * 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")
+ *
+ * // 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: string | URL): URL;
-export function aggregateGroups(match: URLPatternResult): Record<string, string | null | undefined>;
+export function aggregateGroups(match: any): Record<string, string | null | undefined>;
 //# sourceMappingURL=localize-url.d.ts.map

package/dist/compiler/runtime/localize-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localize-url.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-url.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,iCALW,MAAM,GAAG,GAAG,WAEpB;IAAwB,MAAM,EAAtB,MAAM;CACd,GAAU,GAAG,CA6Bf;AAKS,mCAAM,MAAM,GAAG,GAAG,GAAK,GAAG,CAAA;AAyF1B,uCAAQ,gBAAgB,GAAK,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA"}
+{"version":3,"file":"localize-url.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-url.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,iCALW,MAAM,GAAG,GAAG,YAEpB;IAAyB,MAAM;CAC/B,GAAU,GAAG,CAoCf;AAuCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,mCAHW,MAAM,GAAG,GAAG,GACV,GAAG,CAkCf;AAmFS,uCAAQ,GAAG,GAAK,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA"}