@inlang/paraglide-js 2.3.2 → 2.5.0

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

@@ -13,5 +13,9 @@ import { locales } from "./variables.js";
  * @returns {locale is Locale}
  */
 export function isLocale(locale) {
-    return !locale ? false : locales.includes(locale);
+    if (typeof locale !== "string")
+        return false;
+    return !locale
+        ? false
+        : locales.some((item) => item.toLowerCase() === locale.toLowerCase());
 }

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { newProject } from "@inlang/sdk";
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
+const runtime = await createParaglide({
+    blob: await newProject({
+        settings: {
+            baseLocale: "en",
+            locales: ["en", "pt-BR", "de-ch"],
+        },
+    }),
+});
+test("returns true for exact matches", () => {
+    expect(runtime.isLocale("pt-BR")).toBe(true);
+});
+test("is case-insensitive", () => {
+    expect(runtime.isLocale("EN")).toBe(true);
+    expect(runtime.isLocale("pt-br")).toBe(true);
+    expect(runtime.isLocale("de-CH")).toBe(true);
+});
+test("returns false for non-existent locales", () => {
+    expect(runtime.isLocale("es")).toBe(false);
+    expect(runtime.isLocale("xx")).toBe(false);
+    expect(runtime.isLocale("")).toBe(false);
+});
+test("returns false for non-string inputs", () => {
+    expect(runtime.isLocale(null)).toBe(false);
+    expect(runtime.isLocale(undefined)).toBe(false);
+    expect(runtime.isLocale(123)).toBe(false);
+    expect(runtime.isLocale({})).toBe(false);
+    expect(runtime.isLocale([])).toBe(false);
+});

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {(newLocale: Locale, options?: { reload?: boolean }) => void | Promise<void>} SetLocaleFn
+ */
 /**
  * Set the locale.
  *
@@ -15,10 +18,11 @@
  * @example
  *   setLocale('en', { reload: false });
  *
- * @type {(newLocale: Locale, options?: { reload?: boolean }) => Promise<any> | void}
+ * @type {SetLocaleFn}
  */
-export let setLocale: (newLocale: Locale, options?: {
+export let setLocale: SetLocaleFn;
+export function overwriteSetLocale(fn: SetLocaleFn): void;
+export type SetLocaleFn = (newLocale: Locale, options?: {
     reload?: boolean;
-}) => Promise<any> | void;
-export function overwriteSetLocale(fn: (newLocale: Locale) => void): void;
+}) => void | Promise<void>;
 //# sourceMappingURL=set-locale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"set-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/set-locale.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sBAFU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAuGlF;AAgBK,uCAFI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,QAIrC"}
+{"version":3,"file":"set-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/set-locale.js"],"names":[],"mappings":"AAgCA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,sBAFU,WAAW,CAyGnB;AAgBK,uCAFI,WAAW,QAIrB;0BA/IY,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC"}

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

@@ -18,6 +18,9 @@ const navigateOrReload = (newLocation) => {
         window.location.reload();
     }
 };
+/**
+ * @typedef {(newLocale: Locale, options?: { reload?: boolean }) => void | Promise<void>} SetLocaleFn
+ */
 /**
  * Set the locale.
  *
@@ -35,7 +38,7 @@ const navigateOrReload = (newLocation) => {
  * @example
  *   setLocale('en', { reload: false });
  *
- * @type {(newLocale: Locale, options?: { reload?: boolean }) => Promise<any> | void}
+ * @type {SetLocaleFn}
  */
 export let setLocale = (newLocale, options) => {
     const optionsWithDefaults = {
@@ -44,6 +47,7 @@ export let setLocale = (newLocale, options) => {
     };
     // locale is already set
     // https://github.com/opral/inlang-paraglide-js/issues/430
+    /** @type {Locale | undefined} */
     let currentLocale;
     try {
         currentLocale = getLocale();
@@ -103,7 +107,7 @@ export let setLocale = (newLocale, options) => {
             const handler = customClientStrategies.get(strat);
             if (handler) {
                 let result = handler.setLocale(newLocale);
-                // Handle async setLocale - fire and forget
+                // Handle async setLocale
                 if (result instanceof Promise) {
                     result = result.catch((error) => {
                         throw new Error(`Custom strategy "${strat}" setLocale failed.`, {
@@ -115,23 +119,20 @@ export let setLocale = (newLocale, options) => {
             }
         }
     }
-    if (!isServer &&
-        optionsWithDefaults.reload &&
-        window.location &&
-        newLocale !== currentLocale) {
-        if (customSetLocalePromises.length) {
-            // Wait for any async custom setLocale functions
-            return Promise.all(customSetLocalePromises).then(() => {
-                navigateOrReload(newLocation);
-            });
-        }
-        else {
+    const runReload = () => {
+        if (!isServer &&
+            optionsWithDefaults.reload &&
+            window.location &&
+            newLocale !== currentLocale) {
             navigateOrReload(newLocation);
         }
+    };
+    if (customSetLocalePromises.length) {
+        return Promise.all(customSetLocalePromises).then(() => {
+            runReload();
+        });
     }
-    else if (customSetLocalePromises.length) {
-        return Promise.all(customSetLocalePromises);
-    }
+    runReload();
     return;
 };
 /**
@@ -146,8 +147,8 @@ export let setLocale = (newLocale, options) => {
  *     return Cookies.set('locale', newLocale)
  *   });
  *
- * @param {(newLocale: Locale) => void} fn
+ * @param {SetLocaleFn} fn
  */
 export const overwriteSetLocale = (fn) => {
-    setLocale = fn;
+    setLocale = /** @type {SetLocaleFn} */ (fn);
 };

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

@@ -155,6 +155,31 @@ test("when strategy precedes URL, it should set the locale and re-direct to the
     expect(globalThis.document.cookie).toBe("PARAGLIDE_LOCALE=en; path=/; max-age=34560000");
     expect(globalThis.window.location.href).toBe("https://example.com/en/some-path");
 });
+test("overwriteSetLocale receives the options object", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["cookie"],
+        cookieName: "PARAGLIDE_LOCALE",
+    });
+    // Provide minimal browser globals to avoid strategy branches failing.
+    /** @ts-expect-error - browser shim for tests */
+    globalThis.document = { cookie: "" };
+    globalThis.window = {
+        location: {
+            href: "https://example.com/en",
+            reload: vi.fn(),
+        },
+    };
+    const spy = vi.fn();
+    runtime.overwriteSetLocale(spy);
+    runtime.setLocale("fr", { reload: false });
+    expect(spy).toHaveBeenCalledWith("fr", { reload: false });
+});
 // https://github.com/opral/inlang-paraglide-js/issues/430
 test("should not reload when setting locale to current locale", async () => {
     // @ts-expect-error - global variable definition

package/dist/compiler/runtime/should-redirect.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @typedef {object} ShouldRedirectServerInput
+ * @property {Request} request
+ * @property {string | URL} [url]
+ * @property {ReturnType<typeof assertIsLocale>} [locale]
+ *
+ * @typedef {object} ShouldRedirectClientInput
+ * @property {undefined} [request]
+ * @property {string | URL} [url]
+ * @property {ReturnType<typeof assertIsLocale>} [locale]
+ *
+ * @typedef {ShouldRedirectServerInput | ShouldRedirectClientInput} ShouldRedirectInput
+ *
+ * @typedef {object} ShouldRedirectResult
+ * @property {boolean} shouldRedirect - Indicates whether the consumer should perform a redirect.
+ * @property {ReturnType<typeof assertIsLocale>} locale - Locale resolved using the configured strategies.
+ * @property {URL | undefined} redirectUrl - Destination URL when a redirect is required.
+ */
+/**
+ * Determines whether a redirect is required to align the current URL with the active locale.
+ *
+ * This helper mirrors the logic that powers `paraglideMiddleware`, but works in both server
+ * and client environments. It evaluates the configured strategies in order, computes the
+ * canonical localized URL, and reports when the current URL does not match.
+ *
+ * When called in the browser without arguments, the current `window.location.href` is used.
+ *
+ * @example
+ * // Client side usage (e.g. TanStack Router beforeLoad hook)
+ * async function beforeLoad({ location }) {
+ *   const decision = await shouldRedirect({ url: location.href });
+ *
+ *   if (decision.shouldRedirect) {
+ *     throw redirect({ to: decision.redirectUrl.href });
+ *   }
+ * }
+ *
+ * @example
+ * // Server side usage with a Request
+ * export async function handle(request) {
+ *   const decision = await shouldRedirect({ request });
+ *
+ *   if (decision.shouldRedirect) {
+ *     return Response.redirect(decision.redirectUrl, 307);
+ *   }
+ *
+ *   return render(request, decision.locale);
+ * }
+ *
+ * @param {ShouldRedirectInput} [input]
+ * @returns {Promise<ShouldRedirectResult>}
+ */
+export function shouldRedirect(input?: ShouldRedirectInput): Promise<ShouldRedirectResult>;
+export type ShouldRedirectServerInput = {
+    request: Request;
+    url?: string | URL | undefined;
+    locale?: ReturnType<typeof assertIsLocale>;
+};
+export type ShouldRedirectClientInput = {
+    request?: undefined;
+    url?: string | URL | undefined;
+    locale?: ReturnType<typeof assertIsLocale>;
+};
+export type ShouldRedirectInput = ShouldRedirectServerInput | ShouldRedirectClientInput;
+export type ShouldRedirectResult = {
+    /**
+     * - Indicates whether the consumer should perform a redirect.
+     */
+    shouldRedirect: boolean;
+    /**
+     * - Locale resolved using the configured strategies.
+     */
+    locale: ReturnType<typeof assertIsLocale>;
+    /**
+     * - Destination URL when a redirect is required.
+     */
+    redirectUrl: URL | undefined;
+};
+import { assertIsLocale } from "./assert-is-locale.js";
+//# sourceMappingURL=should-redirect.d.ts.map

package/dist/compiler/runtime/should-redirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-redirect.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/should-redirect.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,uCAHW,mBAAmB,GACjB,OAAO,CAAC,oBAAoB,CAAC,CAsBzC;;aAvEa,OAAO;;aAEP,UAAU,CAAC,OAAO,cAAc,CAAC;;;cAGjC,SAAS;;aAET,UAAU,CAAC,OAAO,cAAc,CAAC;;kCAElC,yBAAyB,GAAG,yBAAyB;;;;;oBAGpD,OAAO;;;;YACP,UAAU,CAAC,OAAO,cAAc,CAAC;;;;iBACjC,GAAG,GAAG,SAAS;;+BAnBE,uBAAuB"}

package/dist/compiler/runtime/should-redirect.js

@@ -0,0 +1,119 @@
+import { localizeUrl } from "./localize-url.js";
+import { getLocale } from "./get-locale.js";
+import { getUrlOrigin } from "./get-url-origin.js";
+import { extractLocaleFromRequestAsync } from "./extract-locale-from-request-async.js";
+import { assertIsLocale } from "./assert-is-locale.js";
+import { strategy } from "./variables.js";
+/**
+ * @typedef {object} ShouldRedirectServerInput
+ * @property {Request} request
+ * @property {string | URL} [url]
+ * @property {ReturnType<typeof assertIsLocale>} [locale]
+ *
+ * @typedef {object} ShouldRedirectClientInput
+ * @property {undefined} [request]
+ * @property {string | URL} [url]
+ * @property {ReturnType<typeof assertIsLocale>} [locale]
+ *
+ * @typedef {ShouldRedirectServerInput | ShouldRedirectClientInput} ShouldRedirectInput
+ *
+ * @typedef {object} ShouldRedirectResult
+ * @property {boolean} shouldRedirect - Indicates whether the consumer should perform a redirect.
+ * @property {ReturnType<typeof assertIsLocale>} locale - Locale resolved using the configured strategies.
+ * @property {URL | undefined} redirectUrl - Destination URL when a redirect is required.
+ */
+/**
+ * Determines whether a redirect is required to align the current URL with the active locale.
+ *
+ * This helper mirrors the logic that powers `paraglideMiddleware`, but works in both server
+ * and client environments. It evaluates the configured strategies in order, computes the
+ * canonical localized URL, and reports when the current URL does not match.
+ *
+ * When called in the browser without arguments, the current `window.location.href` is used.
+ *
+ * @example
+ * // Client side usage (e.g. TanStack Router beforeLoad hook)
+ * async function beforeLoad({ location }) {
+ *   const decision = await shouldRedirect({ url: location.href });
+ *
+ *   if (decision.shouldRedirect) {
+ *     throw redirect({ to: decision.redirectUrl.href });
+ *   }
+ * }
+ *
+ * @example
+ * // Server side usage with a Request
+ * export async function handle(request) {
+ *   const decision = await shouldRedirect({ request });
+ *
+ *   if (decision.shouldRedirect) {
+ *     return Response.redirect(decision.redirectUrl, 307);
+ *   }
+ *
+ *   return render(request, decision.locale);
+ * }
+ *
+ * @param {ShouldRedirectInput} [input]
+ * @returns {Promise<ShouldRedirectResult>}
+ */
+export async function shouldRedirect(input = {}) {
+    const locale = /** @type {ReturnType<typeof assertIsLocale>} */ (await resolveLocale(input));
+    if (!strategy.includes("url")) {
+        return { shouldRedirect: false, locale, redirectUrl: undefined };
+    }
+    const currentUrl = resolveUrl(input);
+    const localizedUrl = localizeUrl(currentUrl.href, { locale });
+    const shouldRedirectToLocalizedUrl = normalizeUrl(localizedUrl.href) !== normalizeUrl(currentUrl.href);
+    return {
+        shouldRedirect: shouldRedirectToLocalizedUrl,
+        locale,
+        redirectUrl: shouldRedirectToLocalizedUrl ? localizedUrl : undefined,
+    };
+}
+/**
+ * Resolves the locale either from the provided input or by using the configured strategies.
+ *
+ * @param {ShouldRedirectInput} input
+ * @returns {Promise<ReturnType<typeof assertIsLocale>>}
+ */
+async function resolveLocale(input) {
+    if (input.locale) {
+        return assertIsLocale(input.locale);
+    }
+    if (input.request) {
+        return extractLocaleFromRequestAsync(input.request);
+    }
+    return getLocale();
+}
+/**
+ * Resolves the current URL from the provided input or runtime context.
+ *
+ * @param {ShouldRedirectInput} input
+ * @returns {URL}
+ */
+function resolveUrl(input) {
+    if (input.request) {
+        return new URL(input.request.url);
+    }
+    if (input.url instanceof URL) {
+        return new URL(input.url.href);
+    }
+    if (typeof input.url === "string") {
+        return new URL(input.url, getUrlOrigin());
+    }
+    if (typeof window !== "undefined" && window?.location?.href) {
+        return new URL(window.location.href);
+    }
+    throw new Error("shouldRedirect() requires either a request, an absolute URL, or must run in a browser environment.");
+}
+/**
+ * Normalize url for comparison by stripping the trailing slash.
+ *
+ * @param {string} url
+ * @returns {string}
+ */
+function normalizeUrl(url) {
+    const urlObj = new URL(url);
+    urlObj.pathname = urlObj.pathname.replace(/\/$/, "");
+    return urlObj.href;
+}

package/dist/compiler/runtime/should-redirect.test.d.ts

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

package/dist/compiler/runtime/should-redirect.test.d.ts.map

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

package/dist/compiler/runtime/should-redirect.test.js

@@ -0,0 +1,119 @@
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
+import { newProject } from "@inlang/sdk";
+test("shouldRedirect redirects to the strategy-preferred locale on the server", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["cookie", "url"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
+    });
+    const request = new Request("https://example.com/en/dashboard", {
+        headers: {
+            cookie: "PARAGLIDE_LOCALE=fr",
+        },
+    });
+    const decision = await runtime.shouldRedirect({ request });
+    expect(decision.shouldRedirect).toBe(true);
+    expect(decision.redirectUrl?.href).toBe("https://example.com/fr/dashboard");
+    expect(decision.locale).toBe("fr");
+});
+test("shouldRedirect does nothing when the URL already matches", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["cookie", "url"],
+        cookieName: "PARAGLIDE_LOCALE",
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
+    });
+    const request = new Request("https://example.com/fr/dashboard", {
+        headers: {
+            cookie: "PARAGLIDE_LOCALE=fr",
+        },
+    });
+    const decision = await runtime.shouldRedirect({ request });
+    expect(decision.shouldRedirect).toBe(false);
+    expect(decision.redirectUrl).toBeUndefined();
+    expect(decision.locale).toBe("fr");
+});
+test("shouldRedirect falls back to the browser URL when no input is provided", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de"],
+            },
+        }),
+        strategy: ["url", "globalVariable"],
+        isServer: "false",
+        urlPatterns: undefined,
+    });
+    const originalWindow = globalThis.window;
+    try {
+        globalThis.window = {
+            location: {
+                href: "https://example.com/en/profile",
+                origin: "https://example.com",
+            },
+        };
+        runtime.overwriteGetLocale(() => "de");
+        const decision = await runtime.shouldRedirect();
+        expect(decision.shouldRedirect).toBe(true);
+        expect(decision.redirectUrl?.href).toBe("https://example.com/de/profile");
+        expect(decision.locale).toBe("de");
+    }
+    finally {
+        if (originalWindow === undefined) {
+            Reflect.deleteProperty(globalThis, "window");
+        }
+        else {
+            globalThis.window = originalWindow;
+        }
+    }
+});
+test("shouldRedirect never suggests a redirect without the url strategy", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["cookie"],
+        cookieName: "PARAGLIDE_LOCALE",
+    });
+    const request = new Request("https://example.com/en/dashboard", {
+        headers: {
+            cookie: "PARAGLIDE_LOCALE=fr",
+        },
+    });
+    const decision = await runtime.shouldRedirect({ request });
+    expect(decision.shouldRedirect).toBe(false);
+    expect(decision.redirectUrl).toBeUndefined();
+    expect(decision.locale).toBe("fr");
+});

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

@@ -25,6 +25,7 @@ export type Runtime = {
     deLocalizeHref: typeof import("./localize-href.js").deLocalizeHref;
     localizeUrl: typeof import("./localize-url.js").localizeUrl;
     deLocalizeUrl: typeof import("./localize-url.js").deLocalizeUrl;
+    shouldRedirect: typeof import("./should-redirect.js").shouldRedirect;
     extractLocaleFromUrl: typeof import("./extract-locale-from-url.js").extractLocaleFromUrl;
     extractLocaleFromRequest: typeof import("./extract-locale-from-request.js").extractLocaleFromRequest;
     extractLocaleFromRequestAsync: typeof import("./extract-locale-from-request-async.js").extractLocaleFromRequestAsync;

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

@@ -1 +1 @@
-{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/type.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,OAAO,EAAE,cAAc,gBAAgB,EAAE,OAAO,CAAC;IACjD,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,YAAY,EAAE,cAAc,gBAAgB,EAAE,YAAY,CAAC;IAC3D,WAAW,EAAE,cAAc,gBAAgB,EAAE,WAAW,CAAC;IACzD,wBAAwB,EAAE,cAAc,gBAAgB,EAAE,wBAAwB,CAAC;IACnF,uBAAuB,EAAE,cAAc,gBAAgB,EAAE,uBAAuB,CAAC;IACjF,qCAAqC,EAAE,cAAc,gBAAgB,EAAE,qCAAqC,CAAC;IAC7G,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,YAAY,EAAE,cAAc,qBAAqB,EAAE,YAAY,CAAC;IAChE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,qBAAqB,EAAE,cAAc,qBAAqB,EAAE,qBAAqB,CAAC;IAClF,gCAAgC,EAAE,cAAc,gBAAgB,EAAE,gCAAgC,CAAC;IACnG,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,YAAY,EAAE,cAAc,oBAAoB,EAAE,YAAY,CAAC;IAC/D,cAAc,EAAE,cAAc,oBAAoB,EAAE,cAAc,CAAC;IACnE,WAAW,EAAE,cAAc,mBAAmB,EAAE,WAAW,CAAC;IAC5D,aAAa,EAAE,cAAc,mBAAmB,EAAE,aAAa,CAAC;IAChE,oBAAoB,EAAE,cAAc,8BAA8B,EAAE,oBAAoB,CAAC;IACzF,wBAAwB,EAAE,cAAc,kCAAkC,EAAE,wBAAwB,CAAC;IACrG,6BAA6B,EAAE,cAAc,wCAAwC,EAAE,6BAA6B,CAAC;IACrH,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,0BAA0B,EAAE,cAAc,oCAAoC,EAAE,0BAA0B,CAAC;IAC3G,2BAA2B,EAAE,cAAc,qCAAqC,EAAE,2BAA2B,CAAC;IAC9G,gBAAgB,EAAE,cAAc,yBAAyB,EAAE,gBAAgB,CAAC;IAC5E,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;IACtF,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;CACtF,CAAC"}
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/type.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,OAAO,EAAE,cAAc,gBAAgB,EAAE,OAAO,CAAC;IACjD,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,YAAY,EAAE,cAAc,gBAAgB,EAAE,YAAY,CAAC;IAC3D,WAAW,EAAE,cAAc,gBAAgB,EAAE,WAAW,CAAC;IACzD,wBAAwB,EAAE,cAAc,gBAAgB,EAAE,wBAAwB,CAAC;IACnF,uBAAuB,EAAE,cAAc,gBAAgB,EAAE,uBAAuB,CAAC;IACjF,qCAAqC,EAAE,cAAc,gBAAgB,EAAE,qCAAqC,CAAC;IAC7G,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,YAAY,EAAE,cAAc,qBAAqB,EAAE,YAAY,CAAC;IAChE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,kBAAkB,EAAE,cAAc,iBAAiB,EAAE,kBAAkB,CAAC;IACxE,qBAAqB,EAAE,cAAc,qBAAqB,EAAE,qBAAqB,CAAC;IAClF,gCAAgC,EAAE,cAAc,gBAAgB,EAAE,gCAAgC,CAAC;IACnG,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,YAAY,EAAE,cAAc,oBAAoB,EAAE,YAAY,CAAC;IAC/D,cAAc,EAAE,cAAc,oBAAoB,EAAE,cAAc,CAAC;IACnE,WAAW,EAAE,cAAc,mBAAmB,EAAE,WAAW,CAAC;IAC5D,aAAa,EAAE,cAAc,mBAAmB,EAAE,aAAa,CAAC;IAChE,cAAc,EAAE,cAAc,sBAAsB,EAAE,cAAc,CAAC;IACrE,oBAAoB,EAAE,cAAc,8BAA8B,EAAE,oBAAoB,CAAC;IACzF,wBAAwB,EAAE,cAAc,kCAAkC,EAAE,wBAAwB,CAAC;IACrG,6BAA6B,EAAE,cAAc,wCAAwC,EAAE,6BAA6B,CAAC;IACrH,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,0BAA0B,EAAE,cAAc,oCAAoC,EAAE,0BAA0B,CAAC;IAC3G,2BAA2B,EAAE,cAAc,qCAAqC,EAAE,2BAA2B,CAAC;IAC9G,gBAAgB,EAAE,cAAc,yBAAyB,EAAE,gBAAgB,CAAC;IAC5E,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;IACtF,0BAA0B,EAAE,cAAc,eAAe,EAAE,0BAA0B,CAAC;CACtF,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/server/middleware.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,oCA9Ca,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,cACrF;IAAE,UAAU,EAAC,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAA;CAAE,GACzC,OAAO,CAAC,QAAQ,CAAC,CA0I7B"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/compiler/server/middleware.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,oCA9Ca,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,cACrF;IAAE,UAAU,EAAC,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAA;CAAE,GACzC,OAAO,CAAC,QAAQ,CAAC,CAyI7B"}

package/dist/compiler/server/middleware.js

@@ -68,30 +68,29 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     else if (!runtime.serverAsyncLocalStorage) {
         runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
     }
-    const locale = await runtime.extractLocaleFromRequestAsync(request);
+    const decision = await runtime.shouldRedirect({ request });
+    const locale = decision.locale;
     const origin = new URL(request.url).origin;
     // if the client makes a request to a URL that doesn't match
     // the localizedUrl, redirect the client to the localized URL
     if (request.headers.get("Sec-Fetch-Dest") === "document" &&
-        runtime.strategy.includes("url")) {
-        const localizedUrl = runtime.localizeUrl(request.url, { locale });
-        if (normalizeURL(localizedUrl.href) !== normalizeURL(request.url)) {
-            // Create headers object with Vary header if preferredLanguage strategy is used
-            /** @type {Record<string, string>} */
-            const headers = {};
-            if (runtime.strategy.includes("preferredLanguage")) {
-                headers["Vary"] = "Accept-Language";
-            }
-            const response = new Response(null, {
-                status: 307,
-                headers: {
-                    Location: localizedUrl.href,
-                    ...headers,
-                },
-            });
-            callbacks?.onRedirect(response);
-            return response;
+        decision.shouldRedirect &&
+        decision.redirectUrl) {
+        // Create headers object with Vary header if preferredLanguage strategy is used
+        /** @type {Record<string, string>} */
+        const headers = {};
+        if (runtime.strategy.includes("preferredLanguage")) {
+            headers["Vary"] = "Accept-Language";
         }
+        const response = new Response(null, {
+            status: 307,
+            headers: {
+                Location: decision.redirectUrl.href,
+                ...headers,
+            },
+        });
+        callbacks?.onRedirect(response);
+        return response;
     }
     // If the strategy includes "url", we need to de-localize the URL
     // before passing it to the server middleware.
@@ -135,18 +134,6 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     }
     return response;
 }
-/**
- * Normalize url for comparison.
- * Strips trailing slash
- * @param {string} url
- * @returns {string} normalized url string
- */
-function normalizeURL(url) {
-    const urlObj = new URL(url);
-    // // strip trailing slash from pathname
-    urlObj.pathname = urlObj.pathname.replace(/\/$/, "");
-    return urlObj.href;
-}
 /**
  * Creates a mock AsyncLocalStorage implementation for environments where
  * native AsyncLocalStorage is not available or disabled.

package/dist/services/env-variables/index.js

@@ -1,5 +1,5 @@
 export const ENV_VARIABLES = {
     PARJS_APP_ID: "library.inlang.paraglideJs",
     PARJS_POSTHOG_TOKEN: undefined,
-    PARJS_PACKAGE_VERSION: "2.3.2",
+    PARJS_PACKAGE_VERSION: "2.5.0",
 };