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

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

@@ -1,3 +1,4 @@
+import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
 /**
  * De-localizes the given localized path.
  *
@@ -24,7 +25,7 @@
  * @returns {string} The de-localized path without the locale prefix.
  */
 export function deLocalizePath(path) {
-    const hasLocale = localeInPath(path);
+    const hasLocale = extractLocaleFromPathname(path);
     if (!hasLocale) {
         return path; // Path is already de-localized
     }

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * Extracts a cookie from the document.
+ *
+ * Will return undefined if the docuement is not available or if the cookie is not set.
+ * The `document` object is not available in server-side rendering, so this function should not be called in that context.
+ *
+ * @returns {string | undefined}
+ */
+export function extractLocaleFromCookie(): string | undefined;
+//# sourceMappingURL=extract-locale-from-cookie.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extract-locale-from-cookie.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-cookie.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,2CAFa,MAAM,GAAG,SAAS,CAQ9B"}

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

@@ -0,0 +1,16 @@
+import { cookieName } from "./cookie-name.js";
+/**
+ * Extracts a cookie from the document.
+ *
+ * Will return undefined if the docuement is not available or if the cookie is not set.
+ * The `document` object is not available in server-side rendering, so this function should not be called in that context.
+ *
+ * @returns {string | undefined}
+ */
+export function extractLocaleFromCookie() {
+    if (typeof document === "undefined" || !document.cookie) {
+        return;
+    }
+    const match = document.cookie.match(new RegExp(`(^| )${cookieName}=([^;]+)`));
+    return match?.[2];
+}

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { test, expect } from "vitest";
+import { createRuntimeForTesting } from "./create-runtime.js";
+test("returns undefined if document is not available", async () => {
+    // @ts-expect-error - global variable definition
+    globalThis.document = undefined;
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+    });
+    expect(runtime.extractLocaleFromCookie()).toBeUndefined();
+});
+test("matches the locale of a cookie", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["cookie"],
+            cookieName: "PARAGLIDE_LOCALE",
+        },
+    });
+    // @ts-expect-error - global variable definition
+    globalThis.document = {};
+    globalThis.document.cookie =
+        "OTHER_COOKIE=fr; PARAGLIDE_LOCALE=de; ANOTHER_COOKIE=en; EXPIRES_COOKIE=es; Max-Age=3600";
+    const locale = runtime.extractLocaleFromCookie();
+    expect(locale).toBe("de");
+});

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

@@ -0,0 +1,13 @@
+/**
+ * Extracts the locale from a given pathname.
+ *
+ * @example
+ *   const pathname = '/en/home';
+ *   const locale = extractLocaleFromPathname(pathname);
+ *   console.log(locale); // 'en'
+ *
+ * @param {string} pathname - The pathname from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+export function extractLocaleFromPathname(pathname: string): Locale | undefined;
+//# sourceMappingURL=extract-locale-from-pathname.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,19 @@
+import { isLocale } from "./is-locale.js";
+/**
+ * Extracts the locale from a given pathname.
+ *
+ * @example
+ *   const pathname = '/en/home';
+ *   const locale = extractLocaleFromPathname(pathname);
+ *   console.log(locale); // 'en'
+ *
+ * @param {string} pathname - The pathname from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+export function extractLocaleFromPathname(pathname) {
+    const [, maybeLocale] = pathname.split("/");
+    if (isLocale(maybeLocale)) {
+        return maybeLocale;
+    }
+    return undefined;
+}

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { test, expect } from "vitest";
+import { createRuntimeForTesting } from "./create-runtime.js";
+test("returns the locale from the path", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "en-US"],
+    });
+    const path = "/en-US/about";
+    const locale = runtime.extractLocaleFromPathname(path);
+    expect(locale).toBe("en-US");
+});
+test("returns undefined if isLocale is false", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    const path = "/en-US/about";
+    const locale = runtime.extractLocaleFromPathname(path);
+    expect(locale).toBe(undefined);
+});

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

@@ -0,0 +1,10 @@
+/**
+ * Detect a locale from a request.
+ *
+ * @example
+ *   const locale = extractLocaleFromRequest(request);
+ *
+ * @type {(request: Request) => Locale}
+ */
+export const extractLocaleFromRequest: (request: Request) => Locale;
+//# sourceMappingURL=extract-locale-from-request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extract-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,uCAFU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CA6BpC"}

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

@@ -0,0 +1,42 @@
+import { assertIsLocale } from "./assert-is-locale.js";
+import { baseLocale } from "./base-locale.js";
+import { cookieName } from "./cookie-name.js";
+import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
+import { strategy } from "./strategy.js";
+/**
+ * Detect a locale from a request.
+ *
+ * @example
+ *   const locale = extractLocaleFromRequest(request);
+ *
+ * @type {(request: Request) => Locale}
+ */
+export const extractLocaleFromRequest = (request) => {
+    /** @type {string|undefined} */
+    let locale;
+    for (const strat of strategy) {
+        if (strat === "cookie") {
+            locale = request.headers
+                .get("cookie")
+                ?.split("; ")
+                .find((c) => c.startsWith(cookieName + "="))
+                ?.split("=")[1];
+        }
+        else if (strat === "pathname") {
+            locale = extractLocaleFromPathname(new URL(request.url).pathname);
+        }
+        else if (strat === "variable") {
+            locale = _locale;
+        }
+        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/extract-locale-from-request.test.d.ts

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

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

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

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

@@ -0,0 +1,66 @@
+import { test, expect } from "vitest";
+import { createRuntimeForTesting } from "./create-runtime.js";
+test("returns the locale from the cookie", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "fr"],
+        compilerOptions: {
+            strategy: ["cookie"],
+            cookieName: "PARAGLIDE_LOCALE",
+        },
+    });
+    const request = new Request("http://example.com", {
+        headers: {
+            cookie: `PARAGLIDE_LOCALE=fr`,
+        },
+    });
+    const locale = runtime.extractLocaleFromRequest(request);
+    expect(locale).toBe("fr");
+});
+test("returns the locale from the pathname", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+        compilerOptions: {
+            strategy: ["pathname"],
+        },
+    });
+    const request = new Request("http://example.com/en/home");
+    const locale = runtime.extractLocaleFromRequest(request);
+    expect(locale).toBe("en");
+});
+test("returns the baseLocale if no other strategy matches", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+        compilerOptions: {
+            strategy: ["baseLocale"],
+        },
+    });
+    const request = new Request("http://example.com");
+    const locale = runtime.extractLocaleFromRequest(request);
+    expect(locale).toBe("en");
+});
+test("throws an error for unsupported strategy", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+        compilerOptions: {
+            // @ts-expect-error - unsupported strategy
+            strategy: ["unsupported"],
+        },
+    });
+    const request = new Request("http://example.com");
+    expect(() => runtime.extractLocaleFromRequest(request)).toThrow("Unsupported strategy: unsupported");
+});
+test("throws an error if no locale is found", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+        compilerOptions: {
+            strategy: ["cookie"],
+        },
+    });
+    const request = new Request("http://example.com");
+    expect(() => runtime.extractLocaleFromRequest(request)).toThrow("No locale found. There is an error in your strategy. Try adding 'baseLocale' as the very last strategy.");
+});

package/dist/compiler/runtime/get-locale.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Get the current locale.
+ *
+ * @example
+ *   if (getLocale() === 'de') {
+ *     console.log('Germany 🇩🇪');
+ *   } else if (getLocale() === 'nl') {
+ *     console.log('Netherlands 🇳🇱');
+ *   }
+ *
+ * @type {() => Locale}
+ */
+export let getLocale: () => Locale;
+//# sourceMappingURL=get-locale.d.ts.map

package/dist/compiler/runtime/get-locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/get-locale.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;GAWG;AACH,sBAFU,MAAM,MAAM,CA8BpB"}

package/dist/compiler/runtime/get-locale.js

@@ -0,0 +1,52 @@
+import { assertIsLocale } from "./assert-is-locale.js";
+import { baseLocale } from "./base-locale.js";
+import { extractLocaleFromCookie } from "./extract-locale-from-cookie.js";
+import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
+import { strategy } from "./strategy.js";
+/**
+ * This is a fallback to get started with a custom
+ * strategy and avoid type errors.
+ *
+ * The implementation is overwritten
+ * by \`defineGetLocale()\` and \`defineSetLocale()\`.
+ *
+ * @type {Locale|undefined}
+ */
+let _locale;
+/**
+ * Get the current locale.
+ *
+ * @example
+ *   if (getLocale() === 'de') {
+ *     console.log('Germany 🇩🇪');
+ *   } else if (getLocale() === 'nl') {
+ *     console.log('Netherlands 🇳🇱');
+ *   }
+ *
+ * @type {() => Locale}
+ */
+export let getLocale = () => {
+    /** @type {string | undefined} */
+    let locale;
+    for (const strat of strategy) {
+        if (strat === "cookie") {
+            locale = extractLocaleFromCookie();
+        }
+        if (strat === "baseLocale") {
+            locale = baseLocale;
+        }
+        if (strat === "pathname" &&
+            typeof window !== "undefined" &&
+            window.location?.pathname) {
+            locale = extractLocaleFromPathname(window.location.pathname);
+        }
+        if (strat === "variable" && _locale !== undefined) {
+            locale = _locale;
+        }
+        // check if match, else continue loop
+        if (locale !== undefined) {
+            return assertIsLocale(locale);
+        }
+    }
+    throw new Error("No locale found. There is an error in your strategy.");
+};

package/dist/compiler/runtime/get-locale.test.d.ts

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

package/dist/compiler/runtime/get-locale.test.d.ts.map

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

package/dist/compiler/runtime/get-locale.test.js

@@ -0,0 +1,42 @@
+import { test, expect } from "vitest";
+import { createRuntimeForTesting } from "./create-runtime.js";
+test("matching by strategy works", async () => {
+    const baseLocale = "en";
+    const runtime = await createRuntimeForTesting({
+        baseLocale,
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["cookie", "baseLocale"],
+            cookieName: "PARAGLIDE_LOCALE",
+        },
+    });
+    // @ts-expect-error - global variable definition
+    globalThis.document = {};
+    globalThis.document.cookie = "OTHER_COOKIE=blaba;";
+    const locale = runtime.getLocale();
+    expect(locale).toBe(baseLocale);
+});
+test("doesn't throw when using pathname strategy on the server", async () => {
+    const baseLocale = "en";
+    const runtime = await createRuntimeForTesting({
+        baseLocale,
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["pathname", "variable", "baseLocale"],
+        },
+    });
+    expect(() => runtime.getLocale()).not.toThrow();
+    expect(runtime.getLocale()).toBe(baseLocale);
+});
+test("throws if variable is used without baseLocale as fallback strategy", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            strategy: ["variable"],
+        },
+    });
+    expect(() => runtime.getLocale()).toThrow();
+    runtime.setLocale("de");
+    expect(runtime.getLocale()).toBe("de");
+});

package/dist/compiler/runtime/is-locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/is-locale.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,iCAHW,GAAG,GACD,MAAM,IAAI,MAAM,CAI5B"}
+{"version":3,"file":"is-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/is-locale.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,iCAHW,GAAG,GACD,MAAM,IAAI,MAAM,CAI5B"}

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

@@ -1,3 +1,4 @@
+import { locales } from "./locales.js";
 /**
  * Check if something is an available locale.
  *
@@ -12,5 +13,5 @@
  * @returns {locale is Locale}
  */
 export function isLocale(locale) {
-    return locales.includes(locale);
+    return !locale ? false : locales.includes(locale);
 }

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

@@ -0,0 +1,10 @@
+/**
+ * The project's locales that have been specified in the settings.
+ *
+ * @example
+ *   if (locales.includes(userSelectedLocale) === false) {
+ *     throw new Error('Locale is not available');
+ *   }
+ */
+export const locales: readonly ["<base-locale>"];
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/locales.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,iDAAgE"}

package/dist/compiler/runtime/locales.js

@@ -0,0 +1,9 @@
+/**
+ * The project's locales that have been specified in the settings.
+ *
+ * @example
+ *   if (locales.includes(userSelectedLocale) === false) {
+ *     throw new Error('Locale is not available');
+ *   }
+ */
+export const locales = /** @type {const} */ (["<base-locale>"]);

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

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

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

@@ -1,3 +1,6 @@
+import { baseLocale } from "./base-locale.js";
+import { getLocale } from "./get-locale.js";
+import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
 /**
  * Localizes the given path.
  *
@@ -28,7 +31,7 @@
  */
 export function localizePath(path, options) {
     const locale = options?.locale ?? getLocale();
-    const hasLocale = localeInPath(path);
+    const hasLocale = extractLocaleFromPathname(path);
     const pathWithoutLocale = hasLocale
         ? "/" + path.split("/").slice(2).join("/")
         : path;