@inlang/paraglide-js 2.0.13 → 2.2.0

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

@@ -1,2 +1,2 @@
-export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
+export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("unplugin").VitePlugin<any> | import("unplugin").VitePlugin<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,+GAAoC,CAAC"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/vite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,+HAAoC,CAAC"}

package/dist/compiler/compile-bundle.d.ts

@@ -1,4 +1,4 @@
-import type { Bundle, BundleNested, Message } from "@inlang/sdk";
+import type { Bundle, BundleNested, Message, ProjectSettings } from "@inlang/sdk";
 import type { Compiled } from "./types.js";
 export type CompiledBundleWithMessages = {
     /** The compilation result for the bundle index */
@@ -15,5 +15,6 @@ export declare const compileBundle: (args: {
     bundle: BundleNested;
     fallbackMap: Record<string, string | undefined>;
     messageReferenceExpression: (locale: string, bundleId: string) => string;
+    settings?: ProjectSettings;
 }) => CompiledBundleWithMessages;
 //# sourceMappingURL=compile-bundle.d.ts.map

package/dist/compiler/compile-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile-bundle.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK3C,MAAM,MAAM,0BAA0B,GAAG;IACxC,kDAAkD;IAClD,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,gDAAgD;IAChD,QAAQ,EAAE;QACT,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;KACpC,CAAC;CACF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM;IACnC,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAChD,0BAA0B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CACzE,KAAG,0BA0BH,CAAC"}
+{"version":3,"file":"compile-bundle.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EACN,YAAY,EACZ,OAAO,EACP,eAAe,EACf,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK3C,MAAM,MAAM,0BAA0B,GAAG;IACxC,kDAAkD;IAClD,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,gDAAgD;IAChD,QAAQ,EAAE;QACT,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;KACpC,CAAC;CACF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM;IACnC,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAChD,0BAA0B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IACzE,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC3B,KAAG,0BA2BH,CAAC"}

package/dist/compiler/compile-bundle.js

@@ -20,6 +20,7 @@ export const compileBundle = (args) => {
             bundle: args.bundle,
             availableLocales: Object.keys(args.fallbackMap),
             messageReferenceExpression: args.messageReferenceExpression,
+            settings: args.settings,
         }),
         messages: compiledMessages,
     };
@@ -29,6 +30,7 @@ const compileBundleFunction = (args) => {
     const hasInputs = inputs.length > 0;
     const safeBundleId = toSafeModuleId(args.bundle.id);
     const isSafeBundleId = safeBundleId === args.bundle.id;
+    const isFullyTranslated = args.availableLocales.length === args.settings?.locales.length;
     let code = `/**
 * This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
 *
@@ -46,9 +48,8 @@ ${isSafeBundleId ? "export " : ""}const ${safeBundleId} = (inputs${hasInputs ? "
 	const locale = options.locale ?? getLocale()
 	trackMessageCall("${safeBundleId}", locale)
 	${args.availableLocales
-        .map((locale, index) => `${index > 0 ? "	" : ""}if (locale === "${locale}") return ${args.messageReferenceExpression(locale, args.bundle.id)}(inputs)`)
-        .join("\n")}
-	return "${args.bundle.id}"
+        .map((locale, index) => `${index > 0 ? "	" : ""}${!isFullyTranslated || index < args.availableLocales.length - 1 ? `if (locale === "${locale}") ` : ""}return ${args.messageReferenceExpression(locale, args.bundle.id)}(inputs)`)
+        .join("\n")}${!isFullyTranslated ? `\n	return "${args.bundle.id}"` : ""}
 };`;
     if (isSafeBundleId === false) {
         code += `\nexport { ${safeBundleId} as "${escapeForDoubleQuoteString(args.bundle.id)}" }`;

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

@@ -35,6 +35,70 @@ test("compiles to jsdoc", async () => {
         },
         bundle: mockBundle,
         messageReferenceExpression: (locale) => `${toSafeModuleId(locale)}.blue_moon_bottle`,
+        settings: {
+            locales: ["en", "en-US"],
+        },
+    });
+    expect(result.bundle.code).toMatchInlineSnapshot(`"/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. \`en.json\`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{ age: NonNullable<unknown> }} inputs
+* @param {{ locale?: "en" | "en-US" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+export const blue_moon_bottle = (inputs, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.blue_moon_bottle(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("blue_moon_bottle", locale)
+	if (locale === "en") return en.blue_moon_bottle(inputs)
+	return en_us2.blue_moon_bottle(inputs)
+};"`);
+});
+test("compiles to jsdoc with missing translation", async () => {
+    const mockBundle = {
+        id: "blue_moon_bottle",
+        declarations: [{ type: "input-variable", name: "age" }],
+        messages: [
+            {
+                id: "message-id",
+                bundleId: "blue_moon_bottle",
+                locale: "en",
+                selectors: [],
+                variants: [
+                    {
+                        id: "1",
+                        messageId: "message-id",
+                        matches: [],
+                        pattern: [
+                            { type: "text", value: "Hello" },
+                            {
+                                type: "expression",
+                                arg: { type: "variable-reference", name: "age" },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+    const result = compileBundle({
+        fallbackMap: {
+            en: "en",
+            "en-US": "en",
+        },
+        bundle: mockBundle,
+        messageReferenceExpression: (locale) => `${toSafeModuleId(locale)}.blue_moon_bottle`,
+        settings: {
+            locales: ["en", "en-US", "fr"],
+        },
     });
     expect(result.bundle.code).toMatchInlineSnapshot(`"/**
 * This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).

package/dist/compiler/compile-project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile-project.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-project.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,uBAAuB,CAAC;AAU/B;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAU,MAAM;IAC1C,OAAO,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;CACrE,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsEjC,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC9C,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,GACpB,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAY1B"}
+{"version":3,"file":"compile-project.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-project.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,uBAAuB,CAAC;AAU/B;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAU,MAAM;IAC1C,OAAO,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;CACrE,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAuEjC,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC9C,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,GACpB,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAY1B"}

package/dist/compiler/compile-project.js

@@ -36,6 +36,7 @@ export const compileProject = async (args) => {
         bundle,
         fallbackMap,
         messageReferenceExpression: outputStructure.messageReferenceExpression,
+        settings,
     }));
     const output = {
         ["runtime.js"]: createRuntimeFile({

package/dist/compiler/compiler-options.d.ts

@@ -52,6 +52,8 @@ export type CompilerOptions = {
      * server-side takes the globalVariable (because cookie is unavailable),
      * whereas both fallback to the base locale if not available.
      *
+     * Custom strategies with the pattern `custom-[A-Za-z0-9]+` are supported.
+     *
      * @default ["cookie", "globalVariable", "baseLocale"]
      */
     strategy?: Runtime["strategy"];
@@ -104,10 +106,22 @@ export type CompilerOptions = {
     cookieMaxAge?: number;
     /**
      * The host to which the cookie will be sent.
-     * If null, this defaults to the host portion of the current document location and the cookie is not available on subdomains.
-     * Otherwise, subdomains are always included.
+     * If undefined or empty, the domain attribute is omitted from the cookie, scoping it to the exact current domain only (no subdomains).
+     * If specified, the cookie will be available to the specified domain and all its subdomains.
+     *
+     * Use this when you need cookies to be shared across subdomains (e.g., between `app.example.com` and `api.example.com`).
+     * The default behavior (no domain) ensures better compatibility with server-side cookies that don't specify a domain attribute.
+     *
+     * @example
+     * ```ts
+     * // Default: exact domain only (compatible with server-side cookies)
+     * cookieDomain: undefined // Cookie: "PARAGLIDE_LOCALE=en; path=/; max-age=34560000"
+     *
+     * // Subdomain sharing: available across all subdomains
+     * cookieDomain: "example.com" // Cookie: "PARAGLIDE_LOCALE=en; path=/; max-age=34560000; domain=example.com"
+     * ```
      *
-     * @default window.location.hostname
+     * @default "" (no domain attribute, exact domain only)
      */
     cookieDomain?: string;
     /**

package/dist/compiler/compiler-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler-options.d.ts","sourceRoot":"","sources":["../../src/compiler/compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CAcU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;OAcG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;IAChD;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;;;;;;OASG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,EAAE,CAAC,EAAE,GAAG,CAAC;CACT,CAAC"}
+{"version":3,"file":"compiler-options.d.ts","sourceRoot":"","sources":["../../src/compiler/compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CAcU,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC7B;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;OAcG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;IAChD;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;;;;;;OASG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,eAAe,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IACvD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,EAAE,CAAC,EAAE,GAAG,CAAC;CACT,CAAC"}

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

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

@@ -62,8 +62,14 @@ ${injectCode("./assert-is-locale.js")}
 
 ${injectCode("./extract-locale-from-request.js")}
 
+${injectCode("./extract-locale-from-request-async.js")}
+
 ${injectCode("./extract-locale-from-cookie.js")}
 
+${injectCode("./extract-locale-from-header.js")}
+
+${injectCode("./extract-locale-from-navigator.js")}
+
 ${injectCode("./extract-locale-from-url.js")}
 
 ${injectCode("./localize-url.js")}
@@ -74,6 +80,8 @@ ${injectCode("./track-message-call.js")}
 
 ${injectCode("./generate-static-localized-urls.js")}
 
+${injectCode("./strategy.js")}
+
 // ------ TYPES ------
 
 /**

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

@@ -1,7 +1,7 @@
 /**
  * Extracts a cookie from the document.
  *
- * Will return undefined if the docuement is not available or if the cookie is not set.
+ * Will return undefined if the document is not available or if the cookie is not set.
  * The `document` object is not available in server-side rendering, so this function should not be called in that context.
  *
  * @returns {string | undefined}

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

@@ -3,7 +3,7 @@ import { cookieName } from "./variables.js";
 /**
  * Extracts a cookie from the document.
  *
- * Will return undefined if the docuement is not available or if the cookie is not set.
+ * Will return undefined if the document is not available or if the cookie is not set.
  * The `document` object is not available in server-side rendering, so this function should not be called in that context.
  *
  * @returns {string | undefined}

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

@@ -0,0 +1,2 @@
+export function extractLocaleFromHeader(request: Request): Locale;
+//# sourceMappingURL=extract-locale-from-header.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extract-locale-from-header.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-header.js"],"names":[],"mappings":"AAWU,iDAAU,OAAO,GAAK,MAAM,CAAA"}

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

@@ -0,0 +1,43 @@
+import { isLocale } from "./is-locale.js";
+/**
+ * Extracts a locale from the accept-language header.
+ *
+ * Use the function on the server to extract the locale
+ * from the accept-language header that is sent by the client.
+ *
+ * @example
+ *   const locale = extractLocaleFromHeader(request);
+ *
+ * @type {(request: Request) => Locale}
+ * @param {Request} request - The request object to extract the locale from.
+ * @returns {string|undefined} The negotiated preferred language.
+ */
+export function extractLocaleFromHeader(request) {
+    const acceptLanguageHeader = request.headers.get("accept-language");
+    if (acceptLanguageHeader) {
+        // Parse language preferences with their q-values and base language codes
+        const languages = acceptLanguageHeader
+            .split(",")
+            .map((lang) => {
+            const [tag, q = "1"] = lang.trim().split(";q=");
+            // Get both the full tag and base language code
+            const baseTag = tag?.split("-")[0]?.toLowerCase();
+            return {
+                fullTag: tag?.toLowerCase(),
+                baseTag,
+                q: Number(q),
+            };
+        })
+            .sort((a, b) => b.q - a.q);
+        for (const lang of languages) {
+            if (isLocale(lang.fullTag)) {
+                return lang.fullTag;
+            }
+            else if (isLocale(lang.baseTag)) {
+                return lang.baseTag;
+            }
+        }
+        return undefined;
+    }
+    return undefined;
+}

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

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

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

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

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

@@ -0,0 +1,51 @@
+import { test, expect } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
+import { newProject } from "@inlang/sdk";
+test("returns the preferred locale from Accept-Language header", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+    });
+    // simple direct match
+    const request = new Request("http://example.com", {
+        headers: {
+            "Accept-Language": "en-US;q=0.8,fr;q=0.9,de;q=0.6",
+        },
+    });
+    const locale = runtime.extractLocaleFromHeader(request);
+    expect(locale).toBe("fr");
+    // language tag match
+    const request2 = new Request("http://example.com", {
+        headers: {
+            "Accept-Language": "en-US;q=0.8,nl;q=0.9,de;q=0.7",
+        },
+    });
+    const locale2 = runtime.extractLocaleFromHeader(request2);
+    // Since "nl" isn't in our locales, and "de" has the highest q-value after "nl"
+    expect(locale2).toBe("en");
+    // no match
+    const request3 = new Request("http://example.com", {
+        headers: {
+            "Accept-Language": "nl;q=0.9,es;q=0.6",
+        },
+    });
+    const locale3 = runtime.extractLocaleFromHeader(request3);
+    expect(locale3).toBeUndefined();
+});
+test("returns undefined if no Accept-Language header is present", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+    });
+    const request = new Request("http://example.com");
+    const locale = runtime.extractLocaleFromHeader(request);
+    expect(locale).toBeUndefined();
+});

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

@@ -0,0 +1,2 @@
+export function extractLocaleFromNavigator(): Locale | undefined;
+//# sourceMappingURL=extract-locale-from-navigator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extract-locale-from-navigator.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-navigator.js"],"names":[],"mappings":"AAWU,8CAAM,MAAM,GAAG,SAAS,CAAA"}

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

@@ -0,0 +1,31 @@
+import { isLocale } from "./is-locale.js";
+/**
+ * Negotiates a preferred language from navigator.languages.
+ *
+ * Use the function on the client to extract the locale
+ * from the navigator.languages array.
+ *
+ * @example
+ *   const locale = extractLocaleFromNavigator();
+ *
+ * @type {() => Locale | undefined}
+ * @returns {string | undefined}
+ */
+export function extractLocaleFromNavigator() {
+    if (!navigator?.languages?.length) {
+        return undefined;
+    }
+    const languages = navigator.languages.map((lang) => ({
+        fullTag: lang.toLowerCase(),
+        baseTag: lang.split("-")[0]?.toLowerCase(),
+    }));
+    for (const lang of languages) {
+        if (isLocale(lang.fullTag)) {
+            return lang.fullTag;
+        }
+        else if (isLocale(lang.baseTag)) {
+            return lang.baseTag;
+        }
+    }
+    return undefined;
+}

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { newProject } from "@inlang/sdk";
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
+test("returns the preferred locale from navigator.languages", async () => {
+    const originalNavigator = globalThis.navigator;
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        isServer: "false",
+        strategy: ["preferredLanguage"],
+    });
+    // Mock navigator.languages
+    Object.defineProperty(globalThis, "navigator", {
+        value: {
+            languages: ["fr-FR", "en-US", "de"],
+        },
+        configurable: true,
+    });
+    expect(runtime.getLocale()).toBe("fr");
+    // Restore original navigator
+    Object.defineProperty(globalThis, "navigator", {
+        value: originalNavigator,
+        configurable: true,
+    });
+});

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

@@ -0,0 +1,31 @@
+/**
+ * Asynchronously extracts a locale from a request.
+ *
+ * This function supports async custom server strategies, unlike the synchronous
+ * `extractLocaleFromRequest`. Use this function when you have custom server strategies
+ * that need to perform asynchronous operations (like database calls) in their getLocale method.
+ *
+ * The function first processes any custom server strategies asynchronously, then falls back
+ * to the synchronous `extractLocaleFromRequest` for all other strategies.
+ *
+ * @see {@link https://github.com/opral/inlang-paraglide-js/issues/527#issuecomment-2978151022}
+ *
+ * @example
+ *   // Basic usage
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @example
+ *   // With custom async server strategy
+ *   defineCustomServerStrategy("custom-database", {
+ *     getLocale: async (request) => {
+ *       const userId = extractUserIdFromRequest(request);
+ *       return await getUserLocaleFromDatabase(userId);
+ *     }
+ *   });
+ *
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @type {(request: Request) => Promise<Locale>}
+ */
+export const extractLocaleFromRequestAsync: (request: Request) => Promise<Locale>;
+//# sourceMappingURL=extract-locale-from-request-async.d.ts.map

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

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

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

@@ -0,0 +1,55 @@
+import { customServerStrategies, isCustomStrategy } from "./strategy.js";
+import { strategy } from "./variables.js";
+import { assertIsLocale } from "./assert-is-locale.js";
+import { isLocale } from "./is-locale.js";
+import { extractLocaleFromRequest } from "./extract-locale-from-request.js";
+/**
+ * Asynchronously extracts a locale from a request.
+ *
+ * This function supports async custom server strategies, unlike the synchronous
+ * `extractLocaleFromRequest`. Use this function when you have custom server strategies
+ * that need to perform asynchronous operations (like database calls) in their getLocale method.
+ *
+ * The function first processes any custom server strategies asynchronously, then falls back
+ * to the synchronous `extractLocaleFromRequest` for all other strategies.
+ *
+ * @see {@link https://github.com/opral/inlang-paraglide-js/issues/527#issuecomment-2978151022}
+ *
+ * @example
+ *   // Basic usage
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @example
+ *   // With custom async server strategy
+ *   defineCustomServerStrategy("custom-database", {
+ *     getLocale: async (request) => {
+ *       const userId = extractUserIdFromRequest(request);
+ *       return await getUserLocaleFromDatabase(userId);
+ *     }
+ *   });
+ *
+ *   const locale = await extractLocaleFromRequestAsync(request);
+ *
+ * @type {(request: Request) => Promise<Locale>}
+ */
+export const extractLocaleFromRequestAsync = async (request) => {
+    /** @type {string|undefined} */
+    let locale;
+    // Process custom strategies first, in order
+    for (const strat of strategy) {
+        if (isCustomStrategy(strat) && customServerStrategies.has(strat)) {
+            const handler = customServerStrategies.get(strat);
+            if (handler) {
+                /** @type {string|undefined} */
+                locale = await handler.getLocale(request);
+            }
+            // If we got a valid locale from this custom strategy, use it
+            if (locale !== undefined && isLocale(locale)) {
+                return assertIsLocale(locale);
+            }
+        }
+    }
+    // If no custom strategy provided a valid locale, fall back to sync version
+    locale = extractLocaleFromRequest(request);
+    return assertIsLocale(locale);
+};

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

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

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

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

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

@@ -0,0 +1,58 @@
+import { newProject } from "@inlang/sdk";
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
+test("returns locale from custom strategy which is async", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr", "de"],
+            },
+        }),
+        strategy: ["custom-header", "baseLocale"],
+    });
+    class FakeDB {
+        db = new Map();
+        constructor() {
+            this.db.set("1", "fr");
+        }
+        async getUserLocaleById(id) {
+            return this.db.get(id);
+        }
+    }
+    const db = new FakeDB();
+    async function getLocaleFromUserRequest(request) {
+        const userId = request?.headers.get("X-Custom-User-ID") ?? undefined;
+        if (!userId)
+            throw Error("No User ID");
+        const locale = await db.getUserLocaleById(userId);
+        return locale;
+    }
+    runtime.defineCustomServerStrategy("custom-header", {
+        getLocale: async (request) => (await getLocaleFromUserRequest(request)) ?? undefined,
+    });
+    const request = new Request("http://example.com", {
+        headers: {
+            "X-Custom-User-ID": "1",
+        },
+    });
+    const locale = await runtime.extractLocaleFromRequestAsync(request);
+    expect(locale).toBe("fr");
+});
+test("falls back to next strategy when custom strategy returns undefined", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "fr"],
+            },
+        }),
+        strategy: ["custom-fallback", "baseLocale"],
+    });
+    runtime.defineCustomServerStrategy("custom-fallback", {
+        getLocale: () => undefined,
+    });
+    const request = new Request("http://example.com");
+    const locale = await runtime.extractLocaleFromRequestAsync(request);
+    expect(locale).toBe("en"); // Should fall back to baseLocale
+});

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

@@ -8,6 +8,9 @@
  * they are defined. If a strategy returns an invalid locale,
  * it will fall back to the next strategy.
  *
+ * Note: Custom server strategies are not supported in this synchronous version.
+ * Use `extractLocaleFromRequestAsync` if you need custom server strategies with async getLocale methods.
+ *
  * @example
  *   const locale = extractLocaleFromRequest(request);
  *

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

@@ -1 +1 @@
-{"version":3,"file":"extract-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAyCpC"}
+{"version":3,"file":"extract-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAFU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CA0CpC"}