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

package/dist/compiler/jsdoc-types.js

@@ -1,22 +1,26 @@
 export function jsDocBundleFunctionTypes(args) {
-    const inputParams = args.inputs
-        .map((input) => {
-        return `${input.name}: NonNullable<unknown>`;
-    })
-        .join(", ");
     const localesUnion = args.locales.map((locale) => `"${locale}"`).join(" | ");
     return `
-* @param {{ ${inputParams} }} inputs
+* @param {${inputsType(args.inputs)}} inputs
 * @param {{ locale?: ${localesUnion} }} options
 * @returns {string}`;
 }
-export function jsDocMessageFunctionTypes(args) {
-    const inputParams = args.inputs
+/**
+ * Returns the types for the input variables.
+ *
+ * @example
+ *   const inputs = [{ name: "age" }]
+ *   inputsType(inputs)
+ *   >> "{ age: NonNullable<unknown> }"
+ */
+export function inputsType(inputs) {
+    if (inputs.length === 0) {
+        return "{}";
+    }
+    const inputParams = inputs
         .map((input) => {
         return `${input.name}: NonNullable<unknown>`;
     })
         .join(", ");
-    return `/**
-* @param {{ ${inputParams} }} i
-*/`;
+    return `{ ${inputParams} }`;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"locale-modules.d.ts","sourceRoot":"","sources":["../../../src/compiler/output-structure/locale-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAIvE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,wBAAgB,qBAAqB,CACpC,eAAe,EAAE,0BAA0B,EAAE,EAC7C,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,YAAY,CAAC,EACzD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EAC/C,eAAe,EAAE;IAChB,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;IACnD,UAAU,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;CACvD,GACC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0DxB"}
+{"version":3,"file":"locale-modules.d.ts","sourceRoot":"","sources":["../../../src/compiler/output-structure/locale-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAIvE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,wBAAgB,qBAAqB,CACpC,eAAe,EAAE,0BAA0B,EAAE,EAC7C,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,YAAY,CAAC,EACzD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EAC/C,eAAe,EAAE;IAChB,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;IACnD,UAAU,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;CACvD,GACC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwDxB"}

package/dist/compiler/output-structure/locale-modules.js

@@ -24,14 +24,7 @@ export function generateLocaleModules(compiledBundles, settings, fallbackMap, co
     // generate message files
     for (const locale of settings.locales) {
         const filename = `messages/${locale}.${fileExt}`;
-        let file = `
-/** 
- * This file contains language specific functions for tree-shaking. 
- * 
- *! WARNING: Only import from this file if you want to manually
- *! optimize your bundle. Else, import from the \`messages.js\` file. 
- */
-import * as registry from '../registry.${importExt}'`;
+        let file = "";
         for (const compiledBundle of compiledBundles) {
             const compiledMessage = compiledBundle.messages[locale];
             const id = jsIdentifier(compiledBundle.bundle.node.id);
@@ -49,6 +42,10 @@ import * as registry from '../registry.${importExt}'`;
             }
             file += `\n\n${compiledMessage.code}`;
         }
+        // add import if used
+        if (file.includes("registry.")) {
+            file = `import * as registry from "./registry.js"\n` + file;
+        }
         output[filename] = file;
     }
     return output;

package/dist/compiler/runtime/assert-is-locale.js

@@ -1,5 +1,5 @@
 import { isLocale } from "./is-locale.js";
-import { locales } from "./locales.js";
+import { locales } from "./variables.js";
 /**
  * Asserts that the input is a locale.
  *

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

@@ -9,6 +9,8 @@ export declare function createRuntimeFile(args: {
     compilerOptions: {
         strategy: NonNullable<CompilerOptions["strategy"]>;
         cookieName: NonNullable<CompilerOptions["cookieName"]>;
+        pathnames?: CompilerOptions["pathnames"];
+        pathnameBase?: CompilerOptions["pathnameBase"];
     };
 }): string;
 /**
@@ -23,9 +25,6 @@ export declare function createRuntimeFile(args: {
 export declare function createRuntimeForTesting(args: {
     baseLocale: string;
     locales: string[];
-    compilerOptions?: {
-        strategy?: CompilerOptions["strategy"];
-        cookieName?: CompilerOptions["cookieName"];
-    };
+    compilerOptions?: Omit<CompilerOptions, "outdir" | "project" | "fs">;
 }): Promise<Runtime>;
 //# sourceMappingURL=create-runtime.d.ts.map

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,EAA0B,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;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;KACvD,CAAC;CACF,GAAG,MAAM,CA+ET;AAgBD;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE;QACjB,QAAQ,CAAC,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACvC,UAAU,CAAC,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;KAC3C,CAAC;CACF,GAAG,OAAO,CAAC,OAAO,CAAC,CAcnB"}
+{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/create-runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC;;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,SAAS,CAAC,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;QACzC,YAAY,CAAC,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;KAC/C,CAAC;CACF,GAAG,MAAM,CAsHT;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,CAsBnB"}

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

@@ -1,18 +1,30 @@
 import fs from "node:fs";
 import { defaultCompilerOptions } from "../compile.js";
+import * as pathToRegexp from "path-to-regexp";
 /**
  * Returns the code for the `runtime.js` module
  */
 export function createRuntimeFile(args) {
+    const pathnames = args.compilerOptions.pathnames ?? {
+        "/{*path}": Object.fromEntries([
+            ...args.locales.map((locale) => [locale, `/${locale}{/*path}`]),
+            [args.baseLocale, `/{*path}`],
+        ]),
+    };
     return `
-
-${injectCode("./base-locale.js").replace(`<base-locale>`, `${args.baseLocale}`)}
-
-${injectCode("./locales.js").replace(`["<base-locale>"]`, `["${args.locales.join('", "')}"]`)}
-
-${injectCode("./strategy.js").replace(`["variable"]`, `["${args.compilerOptions.strategy.join('", "')}"]`)}
-
-${injectCode("./cookie-name.js").replace(`<cookie-name>`, `${args.compilerOptions.cookieName}`)}
+import * as pathToRegexp from "@inlang/paraglide-js/path-to-regexp";
+
+${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(`<cookie-name>`, `${args.compilerOptions.cookieName}`)
+        .replace(`pathnames = {}`, `pathnames = ${JSON.stringify(pathnames ?? {}, null, 2)}`)
+        .replace(`export const TREE_SHAKE_IS_DEFAULT_PATHNAMES = false;`, `const TREE_SHAKE_IS_DEFAULT_PATHNAMES = ${args.compilerOptions.pathnames ? false : true};`)
+        .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_PATHNAME_STRATEGY_USED = false;`, `const TREE_SHAKE_PATHNAME_STRATEGY_USED = ${args.compilerOptions.strategy.includes("pathname")};`)
+        .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 pathnameBase = undefined;`, `export const pathnameBase = ${args.compilerOptions.pathnameBase ? `"${args.compilerOptions.pathnameBase}"` : "undefined"};`)}
 
 /**
  * Define the \`getLocale()\` function.
@@ -94,7 +106,9 @@ ${injectCode("./extract-locale-from-cookie.js")}
  */
 function injectCode(path) {
     const code = fs.readFileSync(new URL(path, import.meta.url), "utf-8");
-    return code.replace(/import\s+.*?;?\n/g, "");
+    // Regex to match single-line and multi-line imports
+    const importRegex = /import\s+[\s\S]*?from\s+['"][^'"]+['"]\s*;?/g;
+    return code.replace(importRegex, "").trim();
 }
 /**
  * Returns the runtime module as an object for testing purposes.
@@ -111,10 +125,13 @@ export async function createRuntimeForTesting(args) {
         locales: args.locales,
         compilerOptions: {
             ...defaultCompilerOptions,
-            strategy: ["variable"],
             ...args.compilerOptions,
         },
-    });
+    })
+        // remove the import statement for path-to-regexp
+        .replace(`import * as pathToRegexp from "@inlang/paraglide-js/path-to-regexp";`, "");
+    // @ts-expect-error - defining a depdency globally to avoid importing it in the runtime
+    globalThis.pathToRegexp = pathToRegexp;
     return await import("data:text/javascript;base64," +
         Buffer.from(file, "utf-8").toString("base64"));
 }

package/dist/compiler/runtime/de-localize-path.d.ts

@@ -20,8 +20,8 @@
  *  deLocalizePath('/home');
  *  // '/home' (no change)
  *
- * @param {string} path - The localized path to de-localize.
+ * @param {string} pathname - The localized path to de-localize.
  * @returns {string} The de-localized path without the locale prefix.
  */
-export function deLocalizePath(path: string): string;
+export function deLocalizePath(pathname: string): string;
 //# sourceMappingURL=de-localize-path.d.ts.map

package/dist/compiler/runtime/de-localize-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"de-localize-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/de-localize-path.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qCAHW,MAAM,GACJ,MAAM,CAQlB"}
+{"version":3,"file":"de-localize-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/de-localize-path.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,yCAHW,MAAM,GACJ,MAAM,CA+BlB"}

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

@@ -1,4 +1,5 @@
 import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
+import { pathnameBase, pathnames, TREE_SHAKE_IS_DEFAULT_PATHNAMES, } from "./variables.js";
 /**
  * De-localizes the given localized path.
  *
@@ -21,13 +22,31 @@ import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
  *  deLocalizePath('/home');
  *  // '/home' (no change)
  *
- * @param {string} path - The localized path to de-localize.
+ * @param {string} pathname - The localized path to de-localize.
  * @returns {string} The de-localized path without the locale prefix.
  */
-export function deLocalizePath(path) {
-    const hasLocale = extractLocaleFromPathname(path);
-    if (!hasLocale) {
-        return path; // Path is already de-localized
+export function deLocalizePath(pathname) {
+    const url = new URL(pathname, "http://y.com");
+    let path = url.pathname;
+    // no dynamic matching is needed if the default pathnames are used
+    if (TREE_SHAKE_IS_DEFAULT_PATHNAMES) {
+        const locale = extractLocaleFromPathname(path);
+        if (locale)
+            path = path.replace(`/${locale}`, "") || "/";
+        return path + url.search;
     }
-    return "/" + path.split("/").slice(2).join("/");
+    if (pathnameBase && path.startsWith(pathnameBase)) {
+        path = path.replace(pathnameBase, "");
+    }
+    for (const [unLocalizedPattern, locales] of Object.entries(pathnames)) {
+        for (const [, localizedPattern] of Object.entries(locales)) {
+            const match = pathToRegexp.match(localizedPattern)(path);
+            if (match) {
+                return ((pathnameBase || "") +
+                    pathToRegexp.compile(unLocalizedPattern)(match.params) +
+                    url.search);
+            }
+        }
+    }
+    throw new Error("No match found for localized path. Check pathnames option.");
 }

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

@@ -1,47 +1,109 @@
 import { test, expect } from "vitest";
 import { createRuntimeForTesting } from "./create-runtime.js";
-test("removes the locale from a localized path", async () => {
+test("handles path that is the root", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    de: "/de{/*path}",
+                    en: "/{*path}",
+                },
+            },
+        },
     });
-    const path = "/de/home";
-    const result = runtime.deLocalizePath(path);
-    expect(result).toBe("/home");
+    expect(runtime.deLocalizePath("/")).toBe("/");
+    expect(runtime.deLocalizePath("/de")).toBe("/");
 });
-test("returns the same path if there is no locale", async () => {
+test("delocalizes a localized paths", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["pathname"],
+            pathnames: {
+                "/about": {
+                    en: "/UK/about",
+                    de: "/uber-uns",
+                },
+                "/blog/:post/suffix": {
+                    en: "/en/blog/:post/suffix",
+                    de: "/de/artikel/:post/anhang",
+                },
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+            },
+        },
     });
-    const path = "/home";
-    const result = runtime.deLocalizePath(path);
-    expect(result).toBe("/home");
+    // check simple cases
+    expect(runtime.deLocalizePath("/uber-uns")).toBe("/about");
+    expect(runtime.deLocalizePath("/UK/about")).toBe("/about");
+    // check parameters
+    expect(runtime.deLocalizePath("/de/artikel/123/anhang")).toBe("/blog/123/suffix");
+    expect(runtime.deLocalizePath("/en/blog/123/suffix")).toBe("/blog/123/suffix");
+    // check wild cards
+    expect(runtime.deLocalizePath("/de/something")).toBe("/something");
+    expect(runtime.deLocalizePath("/en/something")).toBe("/something");
 });
-test("handles paths with different locales", async () => {
+test("handles query parameters", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
-        locales: ["en", "de", "fr"],
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["pathname"],
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    de: "/de{/*path}",
+                },
+            },
+        },
+    });
+    expect(runtime.deLocalizePath("/en/something?query=123&other=5")).toBe("/something?query=123&other=5");
+});
+test("handles TREE_SHAKE_DEFAULT_PATHNAMES", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["pathname"],
+            // will create default pathnames
+            pathnames: undefined,
+        },
     });
-    const path = "/fr/contact";
-    const result = runtime.deLocalizePath(path);
-    expect(result).toBe("/contact");
+    expect(runtime.deLocalizePath("/")).toBe("/");
+    expect(runtime.deLocalizePath("/de")).toBe("/");
+    expect(runtime.deLocalizePath("/de/something")).toBe("/something");
 });
-test("handles paths with no segments after locale", async () => {
+// https://github.com/opral/inlang-paraglide-js/issues/362
+test("handles pathnameBase for default pathnames option", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            pathnameBase: "/base",
+        },
     });
-    const path = "/en/";
-    const result = runtime.deLocalizePath(path);
-    expect(result).toBe("/");
+    expect(runtime.deLocalizePath("/base/something")).toBe("/base/something");
+    expect(runtime.deLocalizePath("/base/de/something")).toBe("/base/something");
 });
-test("handles paths that are already the root", async () => {
+test("handles pathnameBase for matcher pathnames option", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "de"],
+        compilerOptions: {
+            pathnameBase: "/base",
+            pathnames: {
+                "/{*path}": {
+                    de: "/de{/*path}",
+                    en: "/{*path}",
+                },
+            },
+        },
     });
-    const path = "/";
-    const result = runtime.deLocalizePath(path);
-    expect(result).toBe("/");
+    expect(runtime.deLocalizePath("/base/something")).toBe("/base/something");
+    expect(runtime.deLocalizePath("/base/de/something")).toBe("/base/something");
 });

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

@@ -0,0 +1,27 @@
+/**
+ * De-localizes the given localized path.
+ *
+ * This function removes the locale from the given path, returning the
+ * base path without the locale prefix.
+ *
+ * Useful when you need to work with non-localized paths from a localized routing system.
+ *
+ * @tip
+ *   Use `localizedPath()` for the inverse operation.
+ *
+ * @example
+ *  // Assuming baseLocale = 'en'
+ *  deLocalizedPath('/fr/home');
+ *  // '/home'
+ *
+ *  deLocalizedPath('/en/home');
+ *  // '/home'
+ *
+ *  deLocalizedPath('/home');
+ *  // '/home' (no change)
+ *
+ * @param {string} path - The localized path to de-localize.
+ * @returns {string} The de-localized path without the locale prefix.
+ */
+export function deLocalizedPath(path: string): string;
+//# sourceMappingURL=de-localized-path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"de-localized-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/de-localized-path.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAHW,MAAM,GACJ,MAAM,CAQlB"}

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

@@ -0,0 +1,32 @@
+/**
+ * De-localizes the given localized path.
+ *
+ * This function removes the locale from the given path, returning the
+ * base path without the locale prefix.
+ *
+ * Useful when you need to work with non-localized paths from a localized routing system.
+ *
+ * @tip
+ *   Use `localizedPath()` for the inverse operation.
+ *
+ * @example
+ *  // Assuming baseLocale = 'en'
+ *  deLocalizedPath('/fr/home');
+ *  // '/home'
+ *
+ *  deLocalizedPath('/en/home');
+ *  // '/home'
+ *
+ *  deLocalizedPath('/home');
+ *  // '/home' (no change)
+ *
+ * @param {string} path - The localized path to de-localize.
+ * @returns {string} The de-localized path without the locale prefix.
+ */
+export function deLocalizedPath(path) {
+    const hasLocale = getLocaleFromPath(path);
+    if (!hasLocale) {
+        return path; // Path is already de-localized
+    }
+    return "/" + path.split("/").slice(2).join("/");
+}

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

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

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

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

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

@@ -0,0 +1,48 @@
+import { test, vi, beforeEach, expect, describe } from "vitest";
+import { deLocalizedPath } from "./de-localized-path.js";
+import { mockRuntime } from "./mock-runtime.js";
+// sequential to avoid global variable conflicts
+describe.sequential("delocalizedPath", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    mockRuntime({
+        baseLocale: "en",
+        locales: ["en", "de", "fr"],
+    });
+    test("removes the locale from a localized path", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.getLocaleFromPath = vi.fn().mockReturnValue("de");
+        const path = "/de/home";
+        const result = deLocalizedPath(path);
+        expect(result).toBe("/home");
+    });
+    test("returns the same path if there is no locale", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.getLocaleFromPath = vi.fn().mockReturnValue(undefined);
+        const path = "/home";
+        const result = deLocalizedPath(path);
+        expect(result).toBe("/home");
+    });
+    test("handles paths with different locales", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.getLocaleFromPath = vi.fn().mockReturnValue("fr");
+        const path = "/fr/contact";
+        const result = deLocalizedPath(path);
+        expect(result).toBe("/contact");
+    });
+    test("handles paths with no segments after locale", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.getLocaleFromPath = vi.fn().mockReturnValue("en");
+        const path = "/en/";
+        const result = deLocalizedPath(path);
+        expect(result).toBe("/");
+    });
+    test("handles paths that are already the root", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.getLocaleFromPath = vi.fn().mockReturnValue(undefined);
+        const path = "/";
+        const result = deLocalizedPath(path);
+        expect(result).toBe("/");
+    });
+});

package/dist/compiler/runtime/detect-locale-from-request.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Detect a locale from a request.
+ *
+ * @example
+ *   const locale = detectLocaleFromRequest({
+ *      pathname: '/en/home',
+ *      headers: {
+ *        'accept-language': 'en'
+ *      },
+ *      cookies: {
+ *        'PARAGLIDE_LOCALE': 'fr'
+ *      }
+ *   });
+ *
+ * @type {(args: { pathname: string, headers: Record<string, string>, cookies: Record<string, string> }) => Locale}
+ */
+export const detectLocaleFromRequest: (args: {
+    pathname: string;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+}) => Locale;
+//# sourceMappingURL=detect-locale-from-request.d.ts.map

package/dist/compiler/runtime/detect-locale-from-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/detect-locale-from-request.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,sCAFU,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,KAAK,MAAM,CA6BhH"}

package/dist/compiler/runtime/detect-locale-from-request.js

@@ -0,0 +1,44 @@
+/**
+ * Detect a locale from a request.
+ *
+ * @example
+ *   const locale = detectLocaleFromRequest({
+ *      pathname: '/en/home',
+ *      headers: {
+ *        'accept-language': 'en'
+ *      },
+ *      cookies: {
+ *        'PARAGLIDE_LOCALE': 'fr'
+ *      }
+ *   });
+ *
+ * @type {(args: { pathname: string, headers: Record<string, string>, cookies: Record<string, string> }) => Locale}
+ */
+export const detectLocaleFromRequest = (args) => {
+    /** @type {string|undefined} */
+    let locale;
+    for (const strat of strategy) {
+        if (strat === "cookie") {
+            locale = args.cookies[cookieName];
+        }
+        else if (strat === "pathname") {
+            locale = localeInPath(args.pathname);
+        }
+        else if (strat === "custom") {
+            throw new Error("Custom strategy is not supported for detectLocaleFromRequest");
+        }
+        else if (strat === "variable") {
+            locale = _localeVariable;
+        }
+        else if (strat === "baseLocale") {
+            return baseLocale;
+        }
+        else {
+            throw new Error(`Unsupported strategy: ${strat}`);
+        }
+        if (locale !== undefined) {
+            return assertIsLocale(locale);
+        }
+    }
+    throw new Error("No locale found. There is an error in your strategy. Try adding 'baseLocale' as the very last strategy.");
+};

package/dist/compiler/runtime/e2e.test.d.ts

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

package/dist/compiler/runtime/e2e.test.d.ts.map

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

package/dist/compiler/runtime/e2e.test.js

@@ -0,0 +1,33 @@
+import { expect, test, describe } from "vitest";
+import { createRuntimeForTesting } from "./create-runtime.js";
+describe.each([
+    { pathnameBase: "/base" },
+    {
+        pathnameBase: "/base",
+        pathnames: {
+            "/{*path}": {
+                de: "/de{/*path}",
+                en: "/{*path}",
+            },
+        },
+    },
+])("pathnameBase combinations", (compilerOptions) => {
+    test(`pathnames: ${compilerOptions.pathnames}`, async () => {
+        const runtime = await createRuntimeForTesting({
+            baseLocale: "en",
+            locales: ["en", "de"],
+            compilerOptions,
+        });
+        // it should auto inject the base path to avoid problems with routing frameworks
+        // that might or might not add the base path
+        expect(runtime.localizePath("/hello-world")).toBe("/base/hello-world");
+        // app sets the locale to de
+        runtime.setLocale("de");
+        // localizePath should return the localized path with the base path
+        expect(runtime.localizePath("/hello-world")).toBe("/base/de/hello-world");
+        // deLocalizePath should remove the locale (de)
+        expect(runtime.deLocalizePath("/base/de/hello-world")).toBe("/base/hello-world");
+        // routing from a de route to an another locale
+        expect(runtime.localizePath("/base/de", { locale: "en" })).toBe("/base");
+    });
+});

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

@@ -1,4 +1,4 @@
-import { cookieName } from "./cookie-name.js";
+import { cookieName } from "./variables.js";
 /**
  * Extracts a cookie from the document.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"extract-locale-from-pathname.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-pathname.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,oDAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAS5B"}
+{"version":3,"file":"extract-locale-from-pathname.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-pathname.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,oDAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAyB5B"}