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

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

@@ -1,48 +1,220 @@
-import { test, expect } from "vitest";
+import { test, expect, describe } from "vitest";
 import { createRuntimeForTesting } from "./create-runtime.js";
+test("matches root path and paths", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    de: "/de{/*path}",
+                    en: "/en{/*path}",
+                },
+            },
+        },
+    });
+    expect(runtime.localizePath("/", { locale: "en" })).toBe("/en");
+    expect(runtime.localizePath("/something", { locale: "en" })).toBe("/en/something");
+});
 test("localizes the path based on the return value of getLocale()", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+            },
+        },
     });
     runtime.setLocale("de");
-    const path = "/about";
-    const l10nPath = runtime.localizePath(path);
-    expect(l10nPath).toBe("/de/about");
+    expect(runtime.localizePath("/about")).toBe("/de/about");
+    runtime.setLocale("en");
+    expect(runtime.localizePath("/about")).toBe("/en/about");
+});
+test("trailing slashes are kept as is", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "*path": {
+                    en: "*path",
+                    de: "/de*path",
+                },
+            },
+        },
+    });
+    expect(runtime.localizePath("/about/", { locale: "de" })).toBe("/de/about/");
+});
+test("root path stays root path", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    de: "/de{/*path}",
+                    en: "/{*path}",
+                },
+            },
+        },
+    });
+    expect(runtime.localizePath("/", { locale: "en" })).toBe("/");
+    expect(runtime.localizePath("/", { locale: "de" })).toBe("/de");
 });
-test("keeps trailing slashes if provided", async () => {
+test("catchall pathname pattern", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+            },
+        },
     });
-    const path = "/about/";
-    const l10nPath = runtime.localizePath(path, { locale: "de" });
-    expect(l10nPath).toBe("/de/about/");
+    expect(runtime.localizePath("/about", { locale: "en" })).toBe("/en/about");
+    expect(runtime.localizePath("/about", { locale: "de" })).toBe("/de/about");
+    expect(runtime.localizePath("/blog/123/suffix", { locale: "en" })).toBe("/en/blog/123/suffix");
+    expect(runtime.localizePath("/blog/123/suffix", { locale: "de" })).toBe("/de/blog/123/suffix");
 });
-test("adds no trailing slash for the root path", async () => {
+test("path parameters", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["pathname"],
+            pathnames: {
+                "/blog/:post/suffix": {
+                    en: "/en/blog/:post/suffix",
+                    de: "/de/artikel/:post/anhang",
+                },
+            },
+        },
     });
-    const path = "/";
-    const l10nPath = runtime.localizePath(path, { locale: "de" });
-    expect(l10nPath).toBe("/de");
+    expect(runtime.localizePath("/blog/532/suffix", { locale: "en" })).toBe("/en/blog/532/suffix");
+    expect(runtime.localizePath("/blog/12/suffix", { locale: "de" })).toBe("/de/artikel/12/anhang");
 });
-test("removes the base locale from the path", async () => {
+test("order of defining pathnames matters", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["pathname"],
+            pathnames: {
+                // the catch all has precedence over the parameter pattern
+                // because it is defined first
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+                "/about": {
+                    en: "/en/about",
+                    de: "/de/uber-uns",
+                },
+            },
+        },
     });
-    const path = "/de/about";
-    const l10nPath = runtime.localizePath(path, { locale: "en" });
-    expect(l10nPath).toBe("/about");
+    const runtime2 = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["pathname"],
+            pathnames: {
+                // the catch all has precedence over the parameter pattern
+                // because it is defined first
+                "/about": {
+                    en: "/en/about",
+                    de: "/de/uber-uns",
+                },
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+            },
+        },
+    });
+    expect(runtime.localizePath("/about", { locale: "en" })).toBe("/en/about");
+    expect(runtime.localizePath("/about", { locale: "de" })).toBe("/de/about");
+    expect(runtime2.localizePath("/about", { locale: "en" })).toBe("/en/about");
+    expect(runtime2.localizePath("/about", { locale: "de" })).toBe("/de/uber-uns");
+});
+test("handles query parameters", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+            },
+        },
+    });
+    expect(runtime.localizePath("/about?query=1", { locale: "en" })).toBe("/en/about?query=1");
 });
-test("does not add a slash suffix if it's the root path that is already localized", async () => {
+test("does not double localize already localized paths", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+            },
+        },
+    });
+    // path is already localized
+    expect(runtime.localizePath("/en/about", { locale: "en" })).toBe("/en/about");
+});
+test("handles TREE_SHAKE_DEFAULT_PATHNAMES", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            // auto creates default pathnames for all locales
+            pathnames: undefined,
+        },
+    });
+    expect(runtime.localizePath("/about", { locale: "en" })).toBe("/about");
+    expect(runtime.localizePath("/about", { locale: "de" })).toBe("/de/about");
+    expect(runtime.localizePath("/about/", { locale: "de" })).toBe("/de/about/");
+    expect(runtime.localizePath("/de/about", { locale: "de" })).toBe("/de/about");
+    // switching locale
+    expect(runtime.localizePath("/de/about", { locale: "en" })).toBe("/about");
+});
+// https://github.com/opral/inlang-paraglide-js/issues/362
+describe.each([
+    { pathnameBase: "/base" },
+    {
+        pathnameBase: "/base",
+        pathnames: {
+            "/{*path}": {
+                de: "/de{/*path}",
+                en: "/{*path}",
+            },
+        },
+    },
+])("handles pathnameBase", (compilerOptions) => {
+    test(`pathnames: ${compilerOptions.pathnames}`, async () => {
+        const runtime = await createRuntimeForTesting({
+            baseLocale: "en",
+            locales: ["en", "de"],
+            compilerOptions,
+        });
+        expect(runtime.localizePath("/about", { locale: "en" })).toBe("/base/about");
+        expect(runtime.localizePath("/base", { locale: "de" })).toBe("/base/de");
+        expect(runtime.localizePath("/base/de", { locale: "en" })).toBe("/base");
+        expect(runtime.localizePath("/base/about", { locale: "en" })).toBe("/base/about");
+        expect(runtime.localizePath("/about", { locale: "de" })).toBe("/base/de/about");
+        expect(runtime.localizePath("/base/de/about", { locale: "de" })).toBe("/base/de/about");
     });
-    const path = "/de";
-    const l10nPath = runtime.localizePath(path, { locale: "de" });
-    expect(l10nPath).toBe("/de");
 });

package/dist/compiler/runtime/localized-path.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Localizes the given path.
+ *
+ * This function is useful if you use localized (i18n) routing
+ * in your application.
+ *
+ * Defaults to `getLocale()` if no locale is provided.
+ *
+ * @tip
+ *   Use `deLocalizedPath()` for the inverse operation.
+ *
+ * @example
+ *  // getLocale() = 'en'
+ *  localizedPath('/home'));
+ *  // '/de/home'
+ *
+ *  // enforcing a specific locale
+ *  localizedPath('/home', { locale: 'fr' });
+ *  // '/fr/home'
+ *
+ * @example
+ *   <a href={localizedPath('/home')}>Home</a>
+ *
+ * @param {string} path
+ * @param {Object} [options] - Optional parameters.
+ * @param {Locale} [options.locale] - The locale to use for the path.
+ * @returns {string}
+ */
+export function localizedPath(path: string, options?: {
+    locale?: Locale;
+}): string;
+//# sourceMappingURL=localized-path.d.ts.map

package/dist/compiler/runtime/localized-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localized-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localized-path.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,oCALW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;CACd,GAAU,MAAM,CAgBlB"}

package/dist/compiler/runtime/localized-path.js

@@ -0,0 +1,44 @@
+/**
+ * Localizes the given path.
+ *
+ * This function is useful if you use localized (i18n) routing
+ * in your application.
+ *
+ * Defaults to `getLocale()` if no locale is provided.
+ *
+ * @tip
+ *   Use `deLocalizedPath()` for the inverse operation.
+ *
+ * @example
+ *  // getLocale() = 'en'
+ *  localizedPath('/home'));
+ *  // '/de/home'
+ *
+ *  // enforcing a specific locale
+ *  localizedPath('/home', { locale: 'fr' });
+ *  // '/fr/home'
+ *
+ * @example
+ *   <a href={localizedPath('/home')}>Home</a>
+ *
+ * @param {string} path
+ * @param {Object} [options] - Optional parameters.
+ * @param {Locale} [options.locale] - The locale to use for the path.
+ * @returns {string}
+ */
+export function localizedPath(path, options) {
+    const locale = options?.locale ?? getLocale();
+    const hasLocale = getLocaleFromPath(path);
+    const pathWithoutLocale = hasLocale
+        ? "/" + path.split("/").slice(2).join("/")
+        : path;
+    if (locale === baseLocale) {
+        return pathWithoutLocale;
+    }
+    else if (path === "/" || pathWithoutLocale === "/") {
+        return `/${locale}`;
+    }
+    else {
+        return `/${locale}${pathWithoutLocale}`;
+    }
+}

package/dist/compiler/runtime/localized-path.test.d.ts

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

package/dist/compiler/runtime/localized-path.test.d.ts.map

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

package/dist/compiler/runtime/localized-path.test.js

@@ -0,0 +1,42 @@
+import { test, vi, beforeEach, expect, describe } from "vitest";
+import { localizedPath } from "./localized-path.js";
+import { mockRuntime } from "./mock-runtime.js";
+// sequential to avoid global variable conflicts
+describe.sequential("", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    mockRuntime({
+        baseLocale: "en",
+        locales: ["en", "de"],
+    });
+    test("localizes the path based on the getLocale definition", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.getLocale = vi.fn().mockReturnValue("de");
+        const path = "/about";
+        const l10nPath = localizedPath(path);
+        expect(l10nPath).toBe("/de/about");
+    });
+    test("keeps trailing slashes if provided", () => {
+        const path = "/about/";
+        const l10nPath = localizedPath(path, { locale: "de" });
+        expect(l10nPath).toBe("/de/about/");
+    });
+    test("adds no trailing slash for the root path", () => {
+        const path = "/";
+        const l10nPath = localizedPath(path, { locale: "de" });
+        expect(l10nPath).toBe("/de");
+    });
+    test("removes the base locale from the path", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.baseLocale = "en";
+        const path = "/de/about";
+        const l10nPath = localizedPath(path, { locale: "en" });
+        expect(l10nPath).toBe("/about");
+    });
+    test("does not add a slash suffix if it's the root path that is already localized", () => {
+        const path = "/de";
+        const l10nPath = localizedPath(path, { locale: "de" });
+        expect(l10nPath).toBe("/de");
+    });
+});

package/dist/compiler/runtime/mock-runtime.d.ts

@@ -0,0 +1,6 @@
+import type { Runtime } from "./type.js";
+export declare function mockRuntime({ baseLocale, locales }: {
+    baseLocale?: string | undefined;
+    locales?: string[] | undefined;
+}): Runtime;
+//# sourceMappingURL=mock-runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/mock-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASzC,wBAAgB,WAAW,CAAC,EAAE,UAAiB,EAAE,OAAsB,EAAE;;;CAAA,WAwBxE"}

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

@@ -0,0 +1,31 @@
+import { localeInPath } from "./locale-in-path.js";
+import { localizePath } from "./localize-path.js";
+import { isLocale } from "./is-locale.js";
+import { deLocalizePath } from "./de-localize-path.js";
+import { assertIsLocale } from "./assert-is-locale.js";
+import { detectLocaleFromRequest } from "./detect-locale-from-request.js";
+import { defaultCompilerOptions } from "../compile.js";
+export function mockRuntime({ baseLocale = "en", locales = ["en", "de"] }) {
+    let locale = baseLocale;
+    const runtime = {
+        baseLocale,
+        locales,
+        cookieName: defaultCompilerOptions.cookieName,
+        strategy: defaultCompilerOptions.strategy,
+        isLocale,
+        assertIsLocale,
+        localeInPath,
+        localizePath,
+        deLocalizePath,
+        detectLocaleFromRequest,
+        defineGetLocale: (fn) => (runtime.getLocale = fn),
+        defineSetLocale: (fn) => (runtime.setLocale = fn),
+        setLocale: (newLocale) => (locale = newLocale),
+        getLocale: () => locale,
+    };
+    for (const [key, value] of Object.entries(runtime)) {
+        // @ts-expect-error - global variable definition
+        globalThis[key] = value;
+    }
+    return runtime;
+}

package/dist/compiler/runtime/path-to-regexp.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=path-to-regexp.d.ts.map

package/dist/compiler/runtime/path-to-regexp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-to-regexp.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/path-to-regexp.js"],"names":[],"mappings":""}

package/dist/compiler/runtime/path-to-regexp.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/runtime/pathname-pattern.d.ts

@@ -0,0 +1,30 @@
+/**
+ *
+ * @param {any} pattern
+ * @param {any} pathname
+ * @returns
+ */
+export function matchPathnamePattern2(pattern: any, pathname: any): {
+    params: {
+        [key: string]: string | undefined;
+    };
+} | undefined;
+/**
+ * Matches a pathname against a pattern with named parameters, wildcards, and optional segments.
+ * Supports path-to-regexp v8 syntax (`/:param`, `/*wildcard`, `/de{/*path}`).
+ *
+ * @param {string} pattern - The pattern to match.
+ * @param {string} pathname - The actual pathname.
+ * @returns {object | undefined} - Matched parameters or `undefined` if no match.
+ */
+export function matchPathnamePattern(pattern: string, pathname: string): object | undefined;
+/**
+ * Generates a pathname from a pattern and parameters.
+ * Supports named parameters (`:param`), optional segments (`{}`), and wildcards (`*param`).
+ *
+ * @param {string} pattern - The pattern to generate the path from.
+ * @param {Record<string, string | string[]>} params - Parameters to replace in the pattern.
+ * @returns {string} - The generated pathname.
+ */
+export function compilePathnamePattern(pattern: string, params: Record<string, string | string[]>): string;
+//# sourceMappingURL=pathname-pattern.d.ts.map

package/dist/compiler/runtime/pathname-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathname-pattern.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/pathname-pattern.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+CAJW,GAAG,YACH,GAAG;;;;cAsBb;AAED;;;;;;;GAOG;AACH,8CAJW,MAAM,YACN,MAAM,GACJ,MAAM,GAAG,SAAS,CAuC9B;AAED;;;;;;;GAOG;AACH,gDAJW,MAAM,UACN,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAC/B,MAAM,CA8BlB"}

package/dist/compiler/runtime/pathname-pattern.js

@@ -0,0 +1,99 @@
+import { URLPattern } from "urlpattern-polyfill/urlpattern";
+/**
+ *
+ * @param {any} pattern
+ * @param {any} pathname
+ * @returns
+ */
+export function matchPathnamePattern2(pattern, pathname) {
+    const matcher = new URLPattern({
+        baseURL: "https://example.com",
+        pathname: pattern,
+    });
+    const match = matcher.exec(new URL(pathname, "https://example.com"));
+    if (!match)
+        return undefined;
+    const params = match.pathname.groups ?? {};
+    for (const key in params) {
+        if (params[key] === undefined) {
+            delete params[key];
+        }
+    }
+    return { params };
+}
+/**
+ * Matches a pathname against a pattern with named parameters, wildcards, and optional segments.
+ * Supports path-to-regexp v8 syntax (`/:param`, `/*wildcard`, `/de{/*path}`).
+ *
+ * @param {string} pattern - The pattern to match.
+ * @param {string} pathname - The actual pathname.
+ * @returns {object | undefined} - Matched parameters or `undefined` if no match.
+ */
+export function matchPathnamePattern(pattern, pathname) {
+    // Ensure pathname doesn't have trailing slashes (unless root `/`)
+    if (pathname !== "/" && pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+    }
+    // Convert `{*param}` to a named capture group `(?<param>.+)`
+    let regexPattern = pattern
+        .replace(/\{\*([^}]+)\}/g, (_, param) => `(?<${param}>.+)`) // ✅ Wildcards `{*param}`
+        .replace(/\{\/\*([^}]+)\}/g, (_, param) => `(?:/(?<${param}>.*?))?`) // ✅ Optional wildcards `{/*param}`
+        .replace(/\{\/:([^}]+)\}/g, (_, param) => `(?:/(?<${param}>[^/]+))?`) // ✅ Optional parameters `{/:param}`
+        .replace(/\/:([^/]+)/g, (_, param) => `/(?<${param}>[^/]+)`) // ✅ Named parameters
+        .replace(/\*([^/]+)/g, (_, param) => `(?<${param}>.+)`); // ✅ Normal wildcards `*param`
+    // Create a RegExp object from the modified pattern
+    const regex = new RegExp(`^${regexPattern}$`);
+    // Attempt to match the pathname
+    const match = pathname.match(regex);
+    if (!match)
+        return undefined;
+    // Extract named parameters
+    /** @type {Record<string, string | string[]>} */
+    const params = match.groups ? { ...match.groups } : {};
+    for (const key in params) {
+        // ✅ Convert wildcard (`*param`) values to arrays to match `path-to-regexp` behavior
+        if (pattern.includes(`*${key}`) && typeof params[key] === "string") {
+            params[key] = params[key] ? params[key].split("/") : [];
+        }
+        // ✅ Remove undefined params (optional parameters)
+        else if (params[key] === undefined) {
+            delete params[key];
+        }
+    }
+    return { params };
+}
+/**
+ * Generates a pathname from a pattern and parameters.
+ * Supports named parameters (`:param`), optional segments (`{}`), and wildcards (`*param`).
+ *
+ * @param {string} pattern - The pattern to generate the path from.
+ * @param {Record<string, string | string[]>} params - Parameters to replace in the pattern.
+ * @returns {string} - The generated pathname.
+ */
+export function compilePathnamePattern(pattern, params) {
+    return (pattern
+        // Replace optional segments `{/:param}`
+        .replace(/\{(\/:[^}]+)\}/g, (_, segment) => {
+        const paramKey = segment.slice(2); // Extract `param` from `/:param`
+        return params[paramKey] ? `/${params[paramKey]}` : "";
+    })
+        // Replace named parameters `/:param`
+        .replace(/\/:([^/]+)/g, (_, paramKey) => {
+        if (params[paramKey] === undefined) {
+            throw new Error(`Missing value for parameter ":${paramKey}"`);
+        }
+        return `/${params[paramKey]}`;
+    })
+        // Replace wildcards `/*param`
+        .replace(/\*([^/]+)/g, (_, paramKey) => {
+        if (!Array.isArray(params[paramKey])) {
+            throw new Error(`Wildcard parameter "*${paramKey}" must be an array`);
+        }
+        return params[paramKey].length > 0
+            ? `/${params[paramKey].join("/")}`
+            : "";
+    })
+        // Ensure the resulting path is correctly formatted
+        .replace(/\/+/g, "/") // Prevent double slashes
+        .replace(/\/$/, "")); // Remove trailing slash unless it's the root `/`
+}

package/dist/compiler/runtime/pathname-pattern.test.d.ts

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

package/dist/compiler/runtime/pathname-pattern.test.d.ts.map

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