@inlang/paraglide-js 2.0.13 → 2.2.0

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

@@ -0,0 +1,60 @@
+/**
+ * Checks if the given strategy is a custom strategy.
+ *
+ * @param {any} strategy The name of the custom strategy to validate.
+ * Must be a string that starts with "custom-" followed by alphanumeric characters, hyphens, or underscores.
+ * @returns {boolean} Returns true if it is a custom strategy, false otherwise.
+ */
+export function isCustomStrategy(strategy: any): boolean;
+/**
+ * Defines a custom strategy that is executed on the server.
+ *
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
+ * @param {CustomServerStrategyHandler} handler The handler for the custom strategy, which should implement
+ * the method getLocale.
+ * @returns {void}
+ */
+export function defineCustomServerStrategy(strategy: any, handler: CustomServerStrategyHandler): void;
+/**
+ * Defines a custom strategy that is executed on the client.
+ *
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
+ * @param {CustomClientStrategyHandler} handler The handler for the custom strategy, which should implement the
+ * methods getLocale and setLocale.
+ * @returns {void}
+ */
+export function defineCustomClientStrategy(strategy: any, handler: CustomClientStrategyHandler): void;
+/**
+ * @typedef {"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage"} BuiltInStrategy
+ */
+/**
+ * @typedef {`custom_${string}`} CustomStrategy
+ */
+/**
+ * @typedef {BuiltInStrategy | CustomStrategy} Strategy
+ */
+/**
+ * @typedef {Array<Strategy>} Strategies
+ */
+/**
+ * @typedef {{ getLocale: (request?: Request) => Promise<string | undefined> | (string | undefined) }} CustomServerStrategyHandler
+ */
+/**
+ * @typedef {{ getLocale: () => Promise<string|undefined> | (string | undefined), setLocale: (locale: string) => Promise<void> | void }} CustomClientStrategyHandler
+ */
+/** @type {Map<string, CustomServerStrategyHandler>} */
+export const customServerStrategies: Map<string, CustomServerStrategyHandler>;
+/** @type {Map<string, CustomClientStrategyHandler>} */
+export const customClientStrategies: Map<string, CustomClientStrategyHandler>;
+export type BuiltInStrategy = "cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage";
+export type CustomStrategy = `custom_${string}`;
+export type Strategy = BuiltInStrategy | CustomStrategy;
+export type Strategies = Array<Strategy>;
+export type CustomServerStrategyHandler = {
+    getLocale: (request?: Request) => Promise<string | undefined> | (string | undefined);
+};
+export type CustomClientStrategyHandler = {
+    getLocale: () => Promise<string | undefined> | (string | undefined);
+    setLocale: (locale: string) => Promise<void> | void;
+};
+//# sourceMappingURL=strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/strategy.js"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,2CAJW,GAAG,GAED,OAAO,CAMnB;AAED;;;;;;;GAOG;AACH,qDALW,GAAG,WACH,2BAA2B,GAEzB,IAAI,CAUhB;AAED;;;;;;;GAOG;AACH,qDALW,GAAG,WACH,2BAA2B,GAEzB,IAAI,CAUhB;AA5ED;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH,uDAAuD;AACvD,qCADW,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,CACH;AAChD,uDAAuD;AACvD,qCADW,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,CACH;8BA1BnC,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,KAAK,GAAG,mBAAmB,GAAG,cAAc;6BAIzF,UAAU,MAAM,EAAE;uBAIlB,eAAe,GAAG,cAAc;yBAIhC,KAAK,CAAC,QAAQ,CAAC;0CAIf;IAAE,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAAE;0CAIxF;IAAE,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,GAAC,SAAS,CAAC,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAAE"}

package/dist/compiler/runtime/strategy.js

@@ -0,0 +1,60 @@
+/**
+ * @typedef {"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage"} BuiltInStrategy
+ */
+/**
+ * @typedef {`custom_${string}`} CustomStrategy
+ */
+/**
+ * @typedef {BuiltInStrategy | CustomStrategy} Strategy
+ */
+/**
+ * @typedef {Array<Strategy>} Strategies
+ */
+/**
+ * @typedef {{ getLocale: (request?: Request) => Promise<string | undefined> | (string | undefined) }} CustomServerStrategyHandler
+ */
+/**
+ * @typedef {{ getLocale: () => Promise<string|undefined> | (string | undefined), setLocale: (locale: string) => Promise<void> | void }} CustomClientStrategyHandler
+ */
+/** @type {Map<string, CustomServerStrategyHandler>} */
+export const customServerStrategies = new Map();
+/** @type {Map<string, CustomClientStrategyHandler>} */
+export const customClientStrategies = new Map();
+/**
+ * Checks if the given strategy is a custom strategy.
+ *
+ * @param {any} strategy The name of the custom strategy to validate.
+ * Must be a string that starts with "custom-" followed by alphanumeric characters, hyphens, or underscores.
+ * @returns {boolean} Returns true if it is a custom strategy, false otherwise.
+ */
+export function isCustomStrategy(strategy) {
+    return (typeof strategy === "string" && /^custom-[A-Za-z0-9_-]+$/.test(strategy));
+}
+/**
+ * Defines a custom strategy that is executed on the server.
+ *
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
+ * @param {CustomServerStrategyHandler} handler The handler for the custom strategy, which should implement
+ * the method getLocale.
+ * @returns {void}
+ */
+export function defineCustomServerStrategy(strategy, handler) {
+    if (!isCustomStrategy(strategy)) {
+        throw new Error(`Invalid custom strategy: "${strategy}". Must be a custom strategy following the pattern custom-name.`);
+    }
+    customServerStrategies.set(strategy, handler);
+}
+/**
+ * Defines a custom strategy that is executed on the client.
+ *
+ * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
+ * @param {CustomClientStrategyHandler} handler The handler for the custom strategy, which should implement the
+ * methods getLocale and setLocale.
+ * @returns {void}
+ */
+export function defineCustomClientStrategy(strategy, handler) {
+    if (!isCustomStrategy(strategy)) {
+        throw new Error(`Invalid custom strategy: "${strategy}". Must be a custom strategy following the pattern custom-name.`);
+    }
+    customClientStrategies.set(strategy, handler);
+}

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

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

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

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

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

@@ -0,0 +1,94 @@
+import { test, expect, describe, beforeEach } from "vitest";
+import { newProject } from "@inlang/sdk";
+import { defineCustomServerStrategy, defineCustomClientStrategy, isCustomStrategy, } from "./strategy.js";
+import { createParaglide } from "../create-paraglide.js";
+describe("isCustomStrategy", () => {
+    test("returns true for valid custom strategy patterns", () => {
+        expect(isCustomStrategy("custom-header")).toBe(true);
+        expect(isCustomStrategy("custom-auth123")).toBe(true);
+        expect(isCustomStrategy("custom-API")).toBe(true);
+        expect(isCustomStrategy("custom-sessionStorage")).toBe(true);
+        expect(isCustomStrategy("custom-oAuth2")).toBe(true);
+        expect(isCustomStrategy("custom-a")).toBe(true);
+        expect(isCustomStrategy("custom-1")).toBe(true);
+        expect(isCustomStrategy("custom-Z")).toBe(true);
+        expect(isCustomStrategy("custom-9")).toBe(true);
+        expect(isCustomStrategy("custom-aZ19")).toBe(true);
+    });
+    test("returns false for invalid custom strategy patterns", () => {
+        expect(isCustomStrategy("")).toBe(false);
+        expect(isCustomStrategy("custom_")).toBe(false);
+        expect(isCustomStrategy("custom-")).toBe(false);
+        expect(isCustomStrategy("header")).toBe(false);
+        expect(isCustomStrategy("custom")).toBe(false);
+        // These are now valid with our relaxed pattern:
+        expect(isCustomStrategy("custom-invalid-name")).toBe(true);
+        expect(isCustomStrategy("custom-invalid_name")).toBe(true);
+        // But spaces and special chars are still invalid:
+        expect(isCustomStrategy("custom-invalid name")).toBe(false);
+        expect(isCustomStrategy("custom-invalid@")).toBe(false);
+        expect(isCustomStrategy("Custom-header")).toBe(false);
+        expect(isCustomStrategy("CUSTOM-header")).toBe(false);
+        expect(isCustomStrategy(null)).toBe(false);
+        expect(isCustomStrategy(undefined)).toBe(false);
+        expect(isCustomStrategy(123)).toBe(false);
+        expect(isCustomStrategy({})).toBe(false);
+        expect(isCustomStrategy([])).toBe(false);
+    });
+    test("returns false for built-in strategy names", () => {
+        expect(isCustomStrategy("cookie")).toBe(false);
+        expect(isCustomStrategy("baseLocale")).toBe(false);
+        expect(isCustomStrategy("globalVariable")).toBe(false);
+        expect(isCustomStrategy("url")).toBe(false);
+        expect(isCustomStrategy("preferredLanguage")).toBe(false);
+        expect(isCustomStrategy("localStorage")).toBe(false);
+    });
+});
+describe.each([
+    ["defineCustomServerStrategy", defineCustomServerStrategy],
+    ["defineCustomClientStrategy", defineCustomClientStrategy],
+])("%s", (strategyName, defineStrategy) => {
+    beforeEach(() => {
+        // Reset global variables before each test
+        if (typeof globalThis !== "undefined") {
+            // @ts-expect-error - Testing environment cleanup
+            delete globalThis.document;
+            // @ts-expect-error - Testing environment cleanup
+            delete globalThis.window;
+            // @ts-expect-error - Testing environment cleanup
+            delete globalThis.localStorage;
+            // @ts-expect-error - Testing environment cleanup
+            delete globalThis.navigator;
+        }
+    });
+    const defaultHandler = { getLocale: () => "en", setLocale: () => { } };
+    const invalidInputs = [
+        ["", "empty name"],
+        ["@invalid", "names with special characters (@)"],
+        ["invalid!", "names with special characters (!)"],
+        ["inva lid", "names with spaces"],
+    ];
+    test.each(invalidInputs)(`${strategyName} throws error for %s (%s)`, (input) => {
+        expect(() => defineStrategy(input, defaultHandler)).toThrow(`Invalid custom strategy: "${input}". Must be a custom strategy following the pattern custom-name.`);
+    });
+    test(`${strategyName} should compile with custom strategies in strategy array`, async () => {
+        // Test that compile accepts custom strategies
+        const runtime = await createParaglide({
+            blob: await newProject({
+                settings: {
+                    baseLocale: "en",
+                    locales: ["en", "de", "fr"],
+                },
+            }),
+            strategy: ["custom-auth", "custom-header", "cookie", "baseLocale"],
+            cookieName: "PARAGLIDE_LOCALE",
+        });
+        // Verify the runtime contains the strategy array
+        expect(runtime.strategy).toEqual([
+            "custom-auth",
+            "custom-header",
+            "cookie",
+            "baseLocale",
+        ]);
+    });
+});

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

@@ -27,8 +27,13 @@ export type Runtime = {
     deLocalizeUrl: typeof import("./localize-url.js").deLocalizeUrl;
     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;
     extractLocaleFromCookie: typeof import("./extract-locale-from-cookie.js").extractLocaleFromCookie;
+    extractLocaleFromHeader: typeof import("./extract-locale-from-header.js").extractLocaleFromHeader;
+    extractLocaleFromNavigator: typeof import("./extract-locale-from-navigator.js").extractLocaleFromNavigator;
     generateStaticLocalizedUrls: typeof import("./generate-static-localized-urls.js").generateStaticLocalizedUrls;
     trackMessageCall: typeof import("./track-message-call.js").trackMessageCall;
+    defineCustomServerStrategy: typeof import("./strategy.js").defineCustomServerStrategy;
+    defineCustomClientStrategy: typeof import("./strategy.js").defineCustomClientStrategy;
 };
 //# sourceMappingURL=type.d.ts.map

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,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;IAClG,2BAA2B,EAAE,cAAc,qCAAqC,EAAE,2BAA2B,CAAC;IAC9G,gBAAgB,EAAE,cAAc,yBAAyB,EAAE,gBAAgB,CAAC;CAC5E,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,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/runtime/variables.d.ts

@@ -36,9 +36,9 @@ export const cookieDomain: string;
 /** @type {string} */
 export const localStorageKey: string;
 /**
- * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage">}
+ * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>}
  */
-export const strategy: Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage">;
+export const strategy: Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>;
 /**
  * The used URL patterns.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/variables.js"],"names":[],"mappings":"AAwEA;;;;;;;;;GASG;AACH,wDAFW,0BAA0B,GAAG,SAAS,QAIhD;AApFD;;;;;;;GAOG;AACH,yBAA0B,IAAI,CAAC;AAE/B;;;;;;;GAOG;AACH,4CAA2D;AAE3D,qBAAqB;AACrB,yBADW,MAAM,CACyB;AAE1C,qBAAqB;AACrB,2BADW,MAAM,CAC8B;AAE/C,qBAAqB;AACrB,2BADW,MAAM,CAC6B;AAE9C,qBAAqB;AACrB,8BADW,MAAM,CACiC;AAElD;;GAEG;AACH,uBAFU,KAAK,CAAC,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,KAAK,GAAG,mBAAmB,GAAG,cAAc,CAAC,CAE/D;AAE3C;;;;GAIG;AACH,0BAFU,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC,CAE1C;AAE9B;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,oCAFU,0BAA0B,GAAG,SAAS,CAED;AAE/C,uCAAwC,KAAK,CAAC;AAE9C,oDAAqD,KAAK,CAAC;AAE3D,+BAAsD;AAgBtD,8CAA+C,KAAK,CAAC;AAErD,2CAA4C,KAAK,CAAC;AAElD,uDAAwD,KAAK,CAAC;AAE9D,0DAA2D,KAAK,CAAC;AAEjE,kDAAmD,KAAK,CAAC;AAEzD,qDAAsD,KAAK,CAAC;yCAnD/C;IACR,QAAQ,IAAI;QACV,MAAM,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KACzB,GAAG,SAAS,CAAC;IACf,GAAG,EAAE,CAAC,KAAK,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KAAC,EAC3E,EAAE,EAAE,GAAG,KAAK,GAAG,CAAA;CACjB"}
+{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/variables.js"],"names":[],"mappings":"AAwEA;;;;;;;;;GASG;AACH,wDAFW,0BAA0B,GAAG,SAAS,QAIhD;AApFD;;;;;;;GAOG;AACH,yBAA0B,IAAI,CAAC;AAE/B;;;;;;;GAOG;AACH,4CAA2D;AAE3D,qBAAqB;AACrB,yBADW,MAAM,CACyB;AAE1C,qBAAqB;AACrB,2BADW,MAAM,CAC8B;AAE/C,qBAAqB;AACrB,2BADW,MAAM,CAC6B;AAE9C,qBAAqB;AACrB,8BADW,MAAM,CACiC;AAElD;;GAEG;AACH,uBAFU,KAAK,CAAC,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,KAAK,GAAG,mBAAmB,GAAG,cAAc,GAAG,UAAU,MAAM,EAAE,CAAC,CAEpF;AAE3C;;;;GAIG;AACH,0BAFU,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC,CAE1C;AAE9B;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,oCAFU,0BAA0B,GAAG,SAAS,CAED;AAE/C,uCAAwC,KAAK,CAAC;AAE9C,oDAAqD,KAAK,CAAC;AAE3D,+BAAsD;AAgBtD,8CAA+C,KAAK,CAAC;AAErD,2CAA4C,KAAK,CAAC;AAElD,uDAAwD,KAAK,CAAC;AAE9D,0DAA2D,KAAK,CAAC;AAEjE,kDAAmD,KAAK,CAAC;AAEzD,qDAAsD,KAAK,CAAC;yCAnD/C;IACR,QAAQ,IAAI;QACV,MAAM,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KACzB,GAAG,SAAS,CAAC;IACf,GAAG,EAAE,CAAC,KAAK,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KAAC,EAC3E,EAAE,EAAE,GAAG,KAAK,GAAG,CAAA;CACjB"}

package/dist/compiler/runtime/variables.js

@@ -25,7 +25,7 @@ export const cookieDomain = "<cookie-domain>";
 /** @type {string} */
 export const localStorageKey = "PARAGLIDE_LOCALE";
 /**
- * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage">}
+ * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>}
  */
 export const strategy = ["globalVariable"];
 /**

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,CA4H7B"}
+{"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"}

package/dist/compiler/server/middleware.js

@@ -68,7 +68,7 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     else if (!runtime.serverAsyncLocalStorage) {
         runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
     }
-    const locale = runtime.extractLocaleFromRequest(request);
+    const locale = await runtime.extractLocaleFromRequestAsync(request);
     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
@@ -76,7 +76,19 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
         runtime.strategy.includes("url")) {
         const localizedUrl = runtime.localizeUrl(request.url, { locale });
         if (normalizeURL(localizedUrl.href) !== normalizeURL(request.url)) {
-            const response = Response.redirect(localizedUrl, 307);
+            // 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;
         }

package/dist/compiler/server/middleware.test.js

@@ -150,6 +150,79 @@ test("call onRedirect callback when redirecting to new url", async () => {
     expect(response.status).toBe(307); // Redirect status code
     expect(response.headers.get("Location")).toBe("https://example.com/fr/some-path");
 });
+test("sets Vary: Accept-Language header when preferredLanguage strategy is used and redirect occurs", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["preferredLanguage", "url"],
+        urlPatterns: [
+            {
+                pattern: "https://example.com/:path(.*)?",
+                localized: [
+                    ["en", "https://example.com/en/:path(.*)?"],
+                    ["fr", "https://example.com/fr/:path(.*)?"],
+                ],
+            },
+        ],
+    });
+    // Request with Accept-Language header preferring French
+    const request = new Request("https://example.com/en/some-path", {
+        headers: {
+            "Accept-Language": "fr,en;q=0.8",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    const response = await runtime.paraglideMiddleware(request, () => {
+        // This shouldn't be called since we should redirect
+        throw new Error("Should not reach here");
+    });
+    expect(response instanceof Response).toBe(true);
+    expect(response.status).toBe(307); // Redirect status code
+    expect(response.headers.get("Location")).toBe("https://example.com/fr/some-path");
+    // Should have Vary header when preferredLanguage strategy is used
+    expect(response.headers.get("Vary")).toBe("Accept-Language");
+});
+test("does not set Vary header when preferredLanguage strategy is not used", 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(.*)?"],
+                ],
+            },
+        ],
+    });
+    // Request with cookie specifying French
+    const request = new Request("https://example.com/en/some-path", {
+        headers: {
+            cookie: `PARAGLIDE_LOCALE=fr`,
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    const response = await runtime.paraglideMiddleware(request, () => {
+        // This shouldn't be called since we should redirect
+        throw new Error("Should not reach here");
+    });
+    expect(response instanceof Response).toBe(true);
+    expect(response.status).toBe(307); // Redirect status code
+    expect(response.headers.get("Location")).toBe("https://example.com/fr/some-path");
+    // Should NOT have Vary header when preferredLanguage strategy is not used
+    expect(response.headers.get("Vary")).toBe(null);
+});
 test("does not call onRedirect callback when there is no redirecting", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
@@ -506,3 +579,193 @@ test("does not catch errors thrown by downstream resolve call", async () => {
         throw new Error("Downstream error");
     })).rejects.toThrow();
 });
+test("middleware supports async custom server strategies", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-database", "baseLocale"],
+    });
+    // Mock an async custom strategy that simulates a database call
+    let databaseCallCount = 0;
+    runtime.defineCustomServerStrategy("custom-database", {
+        getLocale: async (request) => {
+            databaseCallCount++;
+            // Simulate async database call delay
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            // Extract user ID from a custom header (simulating authentication)
+            if (!request)
+                return undefined;
+            const userId = request.headers.get("X-User-ID");
+            if (userId === "user123") {
+                return "fr";
+            }
+            if (userId === "user456") {
+                return "de";
+            }
+            return undefined; // No user preference found
+        },
+    });
+    // Test 1: Request with user preference
+    const requestWithUserPref = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "user123",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    let middlewareResolveWasCalled = false;
+    await runtime.paraglideMiddleware(requestWithUserPref, (args) => {
+        middlewareResolveWasCalled = true;
+        expect(args.locale).toBe("fr"); // Should get locale from async custom strategy
+        return new Response("User preference locale");
+    });
+    expect(middlewareResolveWasCalled).toBe(true);
+    expect(databaseCallCount).toBe(1);
+    // Test 2: Request with different user preference
+    const requestWithOtherUser = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "user456",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    await runtime.paraglideMiddleware(requestWithOtherUser, (args) => {
+        expect(args.locale).toBe("de"); // Should get different locale
+        return new Response("Other user preference");
+    });
+    expect(databaseCallCount).toBe(2);
+});
+test("middleware falls back to other strategies when async custom strategy returns undefined", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-database", "cookie", "baseLocale"],
+        cookieName: "PARAGLIDE_LOCALE",
+    });
+    // Mock async custom strategy that returns undefined for unknown users
+    runtime.defineCustomServerStrategy("custom-database", {
+        getLocale: async (request) => {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            if (!request)
+                return undefined;
+            const userId = request.headers.get("X-User-ID");
+            // Only return locale for known users
+            if (userId === "known-user") {
+                return "fr";
+            }
+            return undefined; // Unknown user, fallback to other strategies
+        },
+    });
+    // Request from unknown user with cookie fallback
+    const request = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "unknown-user",
+            cookie: "PARAGLIDE_LOCALE=de",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    let middlewareResolveWasCalled = false;
+    await runtime.paraglideMiddleware(request, (args) => {
+        middlewareResolveWasCalled = true;
+        expect(args.locale).toBe("de"); // Should fallback to cookie strategy
+        return new Response("Fallback locale");
+    });
+    expect(middlewareResolveWasCalled).toBe(true);
+});
+test("middleware handles async custom strategy errors gracefully", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["custom-database", "baseLocale"],
+    });
+    // Mock async custom strategy that throws an error
+    runtime.defineCustomServerStrategy("custom-database", {
+        getLocale: async () => {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            throw new Error("Database connection failed");
+        },
+    });
+    const request = new Request("https://example.com/page", {
+        headers: { "Sec-Fetch-Dest": "document" },
+    });
+    // The middleware should handle the error and not crash
+    await expect(runtime.paraglideMiddleware(request, (args) => {
+        // If we reach here, the error was handled and fallback worked
+        expect(args.locale).toBe("en"); // Should fallback to baseLocale
+        return new Response("Error handled");
+    })).rejects.toThrow("Database connection failed");
+});
+test("middleware works with multiple async custom strategies", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de", "es"],
+            },
+        }),
+        strategy: ["custom-userPref", "custom-region", "baseLocale"],
+    });
+    let userPrefCallCount = 0;
+    let regionCallCount = 0;
+    // First strategy: user preference
+    runtime.defineCustomServerStrategy("custom-userPref", {
+        getLocale: async (request) => {
+            userPrefCallCount++;
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            if (!request)
+                return undefined;
+            const userId = request.headers.get("X-User-ID");
+            return userId === "premium-user" ? "fr" : undefined;
+        },
+    });
+    // Second strategy: region detection
+    runtime.defineCustomServerStrategy("custom-region", {
+        getLocale: async (request) => {
+            regionCallCount++;
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            if (!request)
+                return undefined;
+            const region = request.headers.get("X-Region");
+            return region === "europe" ? "de" : undefined;
+        },
+    });
+    // Test 1: First strategy succeeds
+    const premiumUserRequest = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "premium-user",
+            "X-Region": "europe",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    await runtime.paraglideMiddleware(premiumUserRequest, (args) => {
+        expect(args.locale).toBe("fr"); // Should use first strategy result
+        return new Response("Premium user");
+    });
+    expect(userPrefCallCount).toBe(1);
+    // Second strategy should not be called since first one succeeded
+    expect(regionCallCount).toBe(0);
+    // Test 2: First strategy fails, second succeeds
+    const regionalUserRequest = new Request("https://example.com/page", {
+        headers: {
+            "X-User-ID": "regular-user",
+            "X-Region": "europe",
+            "Sec-Fetch-Dest": "document",
+        },
+    });
+    await runtime.paraglideMiddleware(regionalUserRequest, (args) => {
+        expect(args.locale).toBe("de"); // Should use second strategy result
+        return new Response("Regional user");
+    });
+    expect(userPrefCallCount).toBe(2);
+    expect(regionCallCount).toBe(1);
+});

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

@@ -1,5 +1,5 @@
 export const ENV_VARIABLES = {
     PARJS_APP_ID: "library.inlang.paraglideJs",
     PARJS_POSTHOG_TOKEN: "phc_m5yJZCxjOGxF8CJvP5sQ3H0d76xpnLrsmiZHduT4jDz",
-    PARJS_PACKAGE_VERSION: "2.0.13",
+    PARJS_PACKAGE_VERSION: "2.2.0",
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.0.13",
+  "version": "2.2.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -31,8 +31,8 @@
     "json5": "2.2.3",
     "unplugin": "^2.1.2",
     "urlpattern-polyfill": "^10.0.0",
-    "@inlang/sdk": "2.4.8",
-    "@inlang/recommend-sherlock": "0.2.1"
+    "@inlang/recommend-sherlock": "0.2.1",
+    "@inlang/sdk": "2.4.9"
   },
   "devDependencies": {
     "@eslint/js": "^9.18.0",
@@ -44,14 +44,14 @@
     "memfs": "4.17.0",
     "prettier": "^3.4.2",
     "rolldown": "1.0.0-beta.1",
-    "typedoc": "0.28.3",
-    "typedoc-plugin-markdown": "^4.6.0",
+    "typedoc": "^0.28.5",
+    "typedoc-plugin-markdown": "^4.7.0",
     "typedoc-plugin-missing-exports": "4.0.0",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.20.0",
     "vitest": "2.1.8",
     "@inlang/plugin-message-format": "4.0.0",
-    "@inlang/paraglide-js": "2.0.13",
+    "@inlang/paraglide-js": "2.2.0",
     "@opral/tsconfig": "1.1.0"
   },
   "keywords": [