@inlang/paraglide-js 2.3.1 → 2.4.0

package/dist/bundler-plugins/vite.d.ts

@@ -1,2 +1,2 @@
-export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("unplugin").VitePlugin<any> | import("unplugin").VitePlugin<any>[];
+export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
 //# sourceMappingURL=vite.d.ts.map

package/dist/bundler-plugins/vite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/vite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,+HAAoC,CAAC"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/vite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,+GAAoC,CAAC"}

package/dist/compiler/compile-project.js

@@ -69,7 +69,7 @@ export const compileProject = async (args) => {
     for (const [filename, content] of Object.entries(output)) {
         if (optionsWithDefaults.includeEslintDisableComment) {
             if (filename.endsWith(".js")) {
-                output[filename] = `// eslint-disable\n${content}`;
+                output[filename] = `/* eslint-disable */\n${content}`;
             }
         }
     }

package/dist/compiler/compile-project.test.js

@@ -70,7 +70,7 @@ test("handles message bundles with a : in the id", async () => {
             },
         }),
     });
-    await insertBundleNested(project.db, createBundleNested({
+    await insertBundleNested(project, createBundleNested({
         id: "hello:world",
         messages: [
             {
@@ -97,7 +97,7 @@ test("can emit message bundles with more than 255 characters", async () => {
             },
         }),
     });
-    await insertBundleNested(project.db, createBundleNested({
+    await insertBundleNested(project, createBundleNested({
         // 300 characters long id
         id: "a".repeat(300),
         messages: [
@@ -199,7 +199,7 @@ describe.each([
                 settings: { locales: ["en", "de"], baseLocale: "en" },
             }),
         });
-        await insertBundleNested(project.db, createBundleNested({
+        await insertBundleNested(project, createBundleNested({
             id: "plural_test",
             declarations: [
                 { type: "input-variable", name: "count" },
@@ -333,7 +333,7 @@ describe.each([
                     settings: { locales: ["en", "de", "en-US"], baseLocale: "en" },
                 }),
             });
-            await insertBundleNested(project.db, createBundleNested({
+            await insertBundleNested(project, createBundleNested({
                 id: "missingInGerman",
                 messages: [
                     {
@@ -363,7 +363,7 @@ describe.each([
                 }),
             });
             // Add test messages
-            await insertBundleNested(project.db, createBundleNested({
+            await insertBundleNested(project, createBundleNested({
                 id: "greeting",
                 messages: [
                     {
@@ -380,7 +380,7 @@ describe.each([
                     },
                 ],
             }));
-            await insertBundleNested(project.db, createBundleNested({
+            await insertBundleNested(project, createBundleNested({
                 id: "farewell",
                 messages: [
                     {
@@ -473,7 +473,7 @@ describe.each([
                     settings: { locales: ["en", "de"], baseLocale: "en" },
                 }),
             });
-            await insertBundleNested(project.db, createBundleNested({
+            await insertBundleNested(project, createBundleNested({
                 id: "$502.23-hello_world",
                 messages: [
                     {
@@ -499,7 +499,7 @@ describe.each([
                     settings: { locales: ["en", "en-US"], baseLocale: "en" },
                 }),
             });
-            await insertBundleNested(project.db, createBundleNested({
+            await insertBundleNested(project, createBundleNested({
                 id: "exists_in_both",
                 messages: [
                     {
@@ -523,7 +523,7 @@ describe.each([
                     },
                 ],
             }));
-            await insertBundleNested(project.db, createBundleNested({
+            await insertBundleNested(project, createBundleNested({
                 id: "missing_in_en_US",
                 messages: [
                     {
@@ -552,7 +552,7 @@ describe.each([
                     settings: { locales: ["en"], baseLocale: "en" },
                 }),
             });
-            await insertBundleNested(project.db, createBundleNested({
+            await insertBundleNested(project, createBundleNested({
                 id: "happy🍌",
                 messages: [
                     {
@@ -578,7 +578,7 @@ describe.each([
             }),
         });
         // Create two bundles with the same name but different case
-        await insertBundleNested(project.db, createBundleNested({
+        await insertBundleNested(project, createBundleNested({
             id: "Helloworld",
             messages: [
                 {
@@ -593,7 +593,7 @@ describe.each([
                 },
             ],
         }));
-        await insertBundleNested(project.db, createBundleNested({
+        await insertBundleNested(project, createBundleNested({
             id: "helloworld",
             messages: [
                 {
@@ -883,7 +883,7 @@ const mockBundles = [
     },
 ];
 for (const bundle of mockBundles) {
-    await insertBundleNested(project.db, bundle);
+    await insertBundleNested(project, bundle);
 }
 function createBundleNested(args) {
     return {

package/dist/compiler/compile.test.js

@@ -237,7 +237,7 @@ test("includes eslint-disable comment", async () => {
         fs: fs,
     });
     const messages = await fs.promises.readFile("/output/messages.js", "utf8");
-    expect(messages).toContain("// eslint-disable");
+    expect(messages).toContain("/* eslint-disable */");
     await compile({
         project: "/project.inlang",
         outdir: "/output",
@@ -245,7 +245,7 @@ test("includes eslint-disable comment", async () => {
         fs: fs,
     });
     const messagesWithoutComment = await fs.promises.readFile("/output/messages.js", "utf8");
-    expect(messagesWithoutComment).not.toContain("// eslint-disable");
+    expect(messagesWithoutComment).not.toContain("/* eslint-disable */");
 });
 test("default compiler options should include cookied, variable and baseLocale to ensure easy try out of paraglide js, working both in server and browser environemnts", () => {
     // someone trying out paraglide js should be able to call `getLocale()` and `setLocale()`
@@ -298,16 +298,29 @@ test("emits warnings for modules that couldn't be imported via http", async () =
     const mock = vi.fn();
     consola.mockTypes(() => mock);
     const fs = memfs().fs;
+    const fetchMock = vi.fn().mockRejectedValue(new TypeError("network error"));
+    vi.stubGlobal("fetch", fetchMock);
+    const errorsSpy = vi.spyOn(project.errors, "get").mockResolvedValue([
+        {
+            message: "Failed to import module https://example.com/non-existent-paraglide-plugin.js",
+        },
+    ]);
     // save project to directory to test loading
     await saveProjectToDirectory({
         project,
         path: "/project.inlang",
         fs: fs.promises,
     });
-    await compile({
-        project: "/project.inlang",
-        outdir: "/output",
-        fs: fs,
-    });
+    try {
+        await compile({
+            project: "/project.inlang",
+            outdir: "/output",
+            fs: fs,
+        });
+    }
+    finally {
+        vi.unstubAllGlobals();
+        errorsSpy.mockRestore();
+    }
     expect(mock).toHaveBeenCalled();
 });

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

@@ -1 +1 @@
-{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/create-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;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,YAAY,EAAE,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC,CAAC;QAC3D,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;QAC9C,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;QAC7C,qCAAqC,EAAE,eAAe,CAAC,uCAAuC,CAAC,CAAC;QAChG,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACtC,eAAe,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC;QACpD,wBAAwB,EAAE,WAAW,CACpC,eAAe,CAAC,0BAA0B,CAAC,CAC3C,CAAC;KACF,CAAC;CACF,GAAG,MAAM,CA0IT"}
+{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/create-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;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,YAAY,EAAE,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC,CAAC;QAC3D,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;QAC9C,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;QAC7C,qCAAqC,EAAE,eAAe,CAAC,uCAAuC,CAAC,CAAC;QAChG,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACtC,eAAe,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC;QACpD,wBAAwB,EAAE,WAAW,CACpC,eAAe,CAAC,0BAA0B,CAAC,CAC3C,CAAC;KACF,CAAC;CACF,GAAG,MAAM,CA4IT"}

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

@@ -74,6 +74,8 @@ ${injectCode("./extract-locale-from-url.js")}
 
 ${injectCode("./localize-url.js")}
 
+${injectCode("./should-redirect.js")}
+
 ${injectCode("./localize-href.js")}
 
 ${injectCode("./track-message-call.js")}

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<void> | 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<void> | 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,IAAI,CAAC,GAAG,IAAI,CAmGnF;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<void> | 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();
@@ -102,31 +106,33 @@ export let setLocale = (newLocale, options) => {
         else if (isCustomStrategy(strat) && customClientStrategies.has(strat)) {
             const handler = customClientStrategies.get(strat);
             if (handler) {
-                const result = handler.setLocale(newLocale);
-                // Handle async setLocale - fire and forget
+                let result = handler.setLocale(newLocale);
+                // Handle async setLocale
                 if (result instanceof Promise) {
-                    result.catch((error) => {
-                        error.message = `Custom strategy "${strat}" setLocale failed: ${error.message}`;
+                    result = result.catch((error) => {
+                        throw new Error(`Custom strategy "${strat}" setLocale failed.`, {
+                            cause: error,
+                        });
                     });
                     customSetLocalePromises.push(result);
                 }
             }
         }
     }
-    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();
+        });
     }
+    runReload();
     return;
 };
 /**
@@ -141,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
@@ -317,6 +342,31 @@ test("calls setLocale on multiple custom strategies", async () => {
     expect(customLocale1).toBe("de");
     expect(customLocale2).toBe("de");
 });
+test("setLocale should return a promise if any custom setLocale function is async", async () => {
+    let customLocale1 = "en";
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-async", "baseLocale"],
+        isServer: "false",
+    });
+    runtime.defineCustomClientStrategy("custom-async", {
+        getLocale: () => customLocale1,
+        setLocale: async (locale) => {
+            customLocale1 = locale;
+        },
+    });
+    const setLocalePromise = runtime.setLocale("de");
+    const setLocalePromiseWithoutReload = runtime.setLocale("de", {
+        reload: false,
+    });
+    expect(setLocalePromise).toBeInstanceOf(Promise);
+    expect(setLocalePromiseWithoutReload).toBeInstanceOf(Promise);
+});
 test("awaits async setLocale functions to resolve in custom strategy", async () => {
     let customLocale1 = "en";
     globalThis.window = {
@@ -408,7 +458,9 @@ test("reload should not run if async setLocale function rejects in custom strate
             throw new Error("fetch error");
         },
     });
-    await expect(() => runtime.setLocale("de")).rejects.toThrowError(`Custom strategy "custom-async" setLocale failed: fetch error`);
+    const error = expect(() => runtime.setLocale("de")).rejects;
+    await error.toThrowError(`Custom strategy "custom-async" setLocale failed.`);
+    await error.toMatchObject({ cause: { message: "fetch error" } });
     // Verify that reload was never called
     expect(window.location.reload).toHaveBeenCalledTimes(0);
     expect(customLocale1).toBe("en");

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.0",
+    PARJS_PACKAGE_VERSION: "2.4.0",
 };

package/dist/services/file-handling/write-output.test.js

@@ -45,8 +45,7 @@ test("should create any missing directories", async () => {
 test("should only write once if the output hasn't changed", async () => {
     const { writeOutput } = await import("./write-output.js");
     const fs = mockFs({});
-    // @ts-expect-error - spy
-    fs.writeFile = vi.spyOn(fs, "writeFile");
+    const writeFileSpy = vi.spyOn(fs, "writeFile");
     const hashes = await writeOutput({
         directory: "/output",
         output: { "test.txt": "test" },
@@ -60,13 +59,12 @@ test("should only write once if the output hasn't changed", async () => {
     });
     expect(hashes).toEqual(hashes2);
     expect(await fs.readFile("/output/test.txt", { encoding: "utf-8" })).toBe("test");
-    expect(fs.writeFile).toHaveBeenCalledTimes(1);
+    expect(writeFileSpy).toHaveBeenCalledTimes(1);
 });
 test("should write again if the output has changed", async () => {
     const { writeOutput } = await import("./write-output.js");
     const fs = mockFs({});
-    // @ts-expect-error - spy
-    fs.writeFile = vi.spyOn(fs, "writeFile");
+    const writeFileSpy = vi.spyOn(fs, "writeFile");
     const hashes = await writeOutput({
         directory: "/output",
         output: { "test.txt": "test" },
@@ -79,13 +77,12 @@ test("should write again if the output has changed", async () => {
         previousOutputHashes: hashes,
     });
     expect(await fs.readFile("/output/test.txt", { encoding: "utf-8" })).toBe("test2");
-    expect(fs.writeFile).toHaveBeenCalledTimes(2);
+    expect(writeFileSpy).toHaveBeenCalledTimes(2);
 });
 test("should write files if output has partially changed", async () => {
     const { writeOutput } = await import("./write-output.js");
     const fs = mockFs({});
-    // @ts-expect-error - spy
-    fs.writeFile = vi.spyOn(fs, "writeFile");
+    const writeFileSpy = vi.spyOn(fs, "writeFile");
     const hashes = await writeOutput({
         directory: "/output",
         output: { "file1.txt": "test", "file2.txt": "test" },
@@ -97,8 +94,8 @@ test("should write files if output has partially changed", async () => {
         fs,
         previousOutputHashes: hashes,
     });
-    expect(fs.writeFile).toHaveBeenCalledWith("/output/file2.txt", "test2");
-    expect(fs.writeFile).toHaveBeenCalledTimes(3);
+    expect(writeFileSpy).toHaveBeenCalledWith("/output/file2.txt", "test2");
+    expect(writeFileSpy).toHaveBeenCalledTimes(3);
 });
 test("should delete files that have been removed from the output", async () => {
     const { writeOutput } = await import("./write-output.js");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -35,21 +35,19 @@
     "@inlang/recommend-sherlock": "0.2.1"
   },
   "devDependencies": {
-    "@eslint/js": "^9.18.0",
     "@rollup/plugin-virtual": "3.0.2",
     "@ts-morph/bootstrap": "0.26.0",
     "@types/node": "^22.10.6",
-    "@vitest/coverage-v8": "2.1.8",
-    "eslint": "^9.18.0",
+    "@vitest/coverage-v8": "3.1.4",
     "memfs": "4.17.0",
+    "oxlint": "^1.14.0",
     "prettier": "^3.4.2",
     "rolldown": "1.0.0-beta.1",
     "typedoc": "0.28.12",
     "typedoc-plugin-markdown": "4.7.0",
     "typedoc-plugin-missing-exports": "4.0.0",
     "typescript": "5.8.3",
-    "typescript-eslint": "^8.20.0",
-    "vitest": "2.1.8",
+    "vitest": "3.1.4",
     "@inlang/plugin-message-format": "4.0.0",
     "@opral/tsconfig": "1.1.0"
   },
@@ -85,7 +83,7 @@
     "test": "npm run env-variables && tsc --noEmit && vitest run --coverage ./src/**/*",
     "test:watch": "npm run env-variables && vitest --watch ./src/**/*",
     "env-variables": "node ./src/services/env-variables/create-index-file.js",
-    "lint": "eslint ./src --fix",
+    "lint": "oxlint --config .oxlintrc.json --fix",
     "format": "prettier ./src --write",
     "clean": "rm -rf ./dist ./node_modules"
   }