tera-system-ui 0.1.63 → 0.1.66

package/dist/paraglide/server.d.ts

@@ -1,6 +1,12 @@
 /**
  * Server middleware that handles locale-based routing and request processing.
  *
+ * Configure `disableAsyncLocalStorage` when generating Paraglide with
+ * `paraglideVitePlugin()` or `compile()`, not when calling
+ * `paraglideMiddleware()`. Keep AsyncLocalStorage enabled by default and
+ * only disable it for runtimes that lack `AsyncLocalStorage` support and
+ * guarantee request isolation.
+ *
  * This middleware performs several key functions:
  *
  * 1. Determines the locale for the incoming request using configured strategies
@@ -23,7 +29,10 @@
  *      If your framework handles URL localization itself (e.g., TanStack Router's `rewrite` option), use the original
  *      request instead to avoid redirect loops.
  *   - `locale`: The determined locale for this request.
- * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
+ * @param {{
+ *   effectiveRequestUrl?: string | URL | ((request: Request) => string | URL),
+ *   onRedirect?: (response: Response) => void
+ * }} [options] - Options to control middleware behavior. `effectiveRequestUrl` sets the effective request URL used for route matching, URL-based locale detection, redirects, and `getUrlOrigin()`.
  * @returns {Promise<Response>}
  *
  * @example
@@ -50,23 +59,6 @@
  *
  * @example
  * ```typescript
- * // Usage in serverless environments like Cloudflare Workers
- * // ⚠️ WARNING: This should ONLY be used in serverless environments like Cloudflare Workers.
- * // Disabling AsyncLocalStorage in traditional server environments risks cross-request pollution where state from
- * // one request could leak into another concurrent request.
- * export default {
- *   fetch: async (request) => {
- *     return paraglideMiddleware(
- *       request,
- *       ({ request, locale }) => handleRequest(request, locale),
- *       { disableAsyncLocalStorage: true }
- *     );
- *   }
- * };
- * ```
- *
- * @example
- * ```typescript
  * // Usage with frameworks that handle URL localization/delocalization themselves
  * //
  * // Some frameworks like TanStack Router handle URL localization and delocalization
@@ -98,6 +90,7 @@
 export function paraglideMiddleware<T>(request: Request, resolve: (args: {
     request: Request;
     locale: import("./runtime.js").Locale;
-}) => T | Promise<T>, callbacks?: {
-    onRedirect: (response: Response) => void;
+}) => T | Promise<T>, options?: {
+    effectiveRequestUrl?: string | URL | ((request: Request) => string | URL);
+    onRedirect?: (response: Response) => void;
 }): Promise<Response>;

package/dist/paraglide/server.js

@@ -5,6 +5,12 @@ import * as runtime from "./runtime.js";
 /**
  * Server middleware that handles locale-based routing and request processing.
  *
+ * Configure `disableAsyncLocalStorage` when generating Paraglide with
+ * `paraglideVitePlugin()` or `compile()`, not when calling
+ * `paraglideMiddleware()`. Keep AsyncLocalStorage enabled by default and
+ * only disable it for runtimes that lack `AsyncLocalStorage` support and
+ * guarantee request isolation.
+ *
  * This middleware performs several key functions:
  *
  * 1. Determines the locale for the incoming request using configured strategies
@@ -27,7 +33,10 @@ import * as runtime from "./runtime.js";
  *      If your framework handles URL localization itself (e.g., TanStack Router's `rewrite` option), use the original
  *      request instead to avoid redirect loops.
  *   - `locale`: The determined locale for this request.
- * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
+ * @param {{
+ *   effectiveRequestUrl?: string | URL | ((request: Request) => string | URL),
+ *   onRedirect?: (response: Response) => void
+ * }} [options] - Options to control middleware behavior. `effectiveRequestUrl` sets the effective request URL used for route matching, URL-based locale detection, redirects, and `getUrlOrigin()`.
  * @returns {Promise<Response>}
  *
  * @example
@@ -54,23 +63,6 @@ import * as runtime from "./runtime.js";
  *
  * @example
  * ```typescript
- * // Usage in serverless environments like Cloudflare Workers
- * // ⚠️ WARNING: This should ONLY be used in serverless environments like Cloudflare Workers.
- * // Disabling AsyncLocalStorage in traditional server environments risks cross-request pollution where state from
- * // one request could leak into another concurrent request.
- * export default {
- *   fetch: async (request) => {
- *     return paraglideMiddleware(
- *       request,
- *       ({ request, locale }) => handleRequest(request, locale),
- *       { disableAsyncLocalStorage: true }
- *     );
- *   }
- * };
- * ```
- *
- * @example
- * ```typescript
  * // Usage with frameworks that handle URL localization/delocalization themselves
  * //
  * // Some frameworks like TanStack Router handle URL localization and delocalization
@@ -99,16 +91,25 @@ import * as runtime from "./runtime.js";
  * }
  * ```
  */
-export async function paraglideMiddleware(request, resolve, callbacks) {
+export async function paraglideMiddleware(request, resolve, options) {
     if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
       const { AsyncLocalStorage } = await import("async_hooks");
       runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
     } else if (!runtime.serverAsyncLocalStorage) {
       runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
     }
-    const decision = await runtime.shouldRedirect({ request });
+    const url = resolveMiddlewareUrl(request, options?.effectiveRequestUrl);
+    const origin = url.origin;
+    if (runtime.isExcludedByRouteStrategy(url.href)) {
+        const locale = runtime.baseLocale;
+        const newRequest = cloneRequestWithFallback(request, url);
+        /** @type {Set<string>} */
+        const messageCalls = new Set();
+        return /** @type {Response} */ (await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest })));
+    }
+    const strategy = runtime.getStrategyForUrl(url.href);
+    const decision = await runtime.shouldRedirect({ request, effectiveRequestUrl: url });
     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" &&
@@ -117,7 +118,7 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
         // Create headers object with Vary header if preferredLanguage strategy is used
         /** @type {Record<string, string>} */
         const headers = {};
-        if (runtime.strategy.includes("preferredLanguage")) {
+        if (strategy.includes("preferredLanguage")) {
             headers["Vary"] = "Accept-Language";
         }
         const response = new Response(null, {
@@ -127,7 +128,7 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
                 ...headers,
             },
         });
-        callbacks?.onRedirect(response);
+        options?.onRedirect?.(response);
         return response;
     }
     // If the strategy includes "url", we need to de-localize the URL
@@ -137,22 +138,11 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     // de-localized URL e.g. `/en/about` to `/about`. Otherwise,
     // the server can't render the correct page.
     let newRequest;
-    if (runtime.strategy.includes("url")) {
-        newRequest = new Request(runtime.deLocalizeUrl(request.url), request);
+    if (strategy.includes("url")) {
+        newRequest = cloneRequestWithFallback(request, runtime.deLocalizeUrl(url));
     }
     else {
-        // Some metaframeworks (NextJS) require a new Request object
-        // https://github.com/opral/inlang-paraglide-js/issues/411
-        // However, some frameworks (TanStack Start 1.143+) use custom Request
-        // implementations that cannot be cloned with `new Request(request)`
-        // https://github.com/opral/paraglide-js/issues/573
-        // Try to clone the request, but fall back to the original if cloning fails
-        try {
-            newRequest = new Request(request);
-        }
-        catch {
-            newRequest = request;
-        }
+        newRequest = cloneRequestWithFallback(request, url);
     }
     // the message functions that have been called in this request
     /** @type {Set<string>} */
@@ -170,7 +160,11 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
             /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
             messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
         }
-        const script = `<script>globalThis.__paraglide_ssr = { ${messages.join(",")} }</script>`;
+        // Prevent translated content from terminating the inline script tag.
+        const escapedMessages = messages
+            .join(",")
+            .replace(/<\/(script)/gi, "<\\/$1");
+        const script = `<script>globalThis.__paraglide = globalThis.__paraglide ?? {}; globalThis.__paraglide.ssr = { ${escapedMessages} }</script>`;
         // Insert the script before the closing head tag
         const newBody = body.replace("</head>", `${script}</head>`);
         // Create a new response with the modified body
@@ -185,13 +179,71 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     }
     return response;
 }
+/**
+ * @param {Request} request
+ * @param {string | URL | ((request: Request) => string | URL) | undefined} effectiveRequestUrl
+ * @returns {URL}
+ */
+function resolveMiddlewareUrl(request, effectiveRequestUrl) {
+    if (typeof effectiveRequestUrl === "function") {
+        return new URL(effectiveRequestUrl(request), request.url);
+    }
+    if (typeof effectiveRequestUrl === "string" || effectiveRequestUrl instanceof URL) {
+        return new URL(effectiveRequestUrl, request.url);
+    }
+    return new URL(request.url);
+}
+/**
+ * Some metaframeworks (NextJS) require a new Request object.
+ * https://github.com/opral/inlang-paraglide-js/issues/411
+ *
+ * However, some frameworks (TanStack Start 1.143+) use custom Request
+ * implementations that cannot be cloned with `new Request(request)`.
+ * https://github.com/opral/paraglide-js/issues/573
+ *
+ * Effective request URL overrides behind proxies:
+ * https://github.com/opral/paraglide-js/issues/652
+ *
+ * @param {Request} request
+ * @param {string | URL} [url]
+ * @returns {Request}
+ */
+function cloneRequestWithFallback(request, url = request.url) {
+    const targetUrl = typeof url === "string" ? url : url.href;
+    if (targetUrl === request.url) {
+        try {
+            // Clone first so building a new Request does not consume the original body stream.
+            return new Request(request.clone());
+        }
+        catch {
+            try {
+                return new Request(request);
+            }
+            catch {
+                return request;
+            }
+        }
+    }
+    try {
+        // Clone first so building a new Request does not consume the original body stream.
+        return new Request(targetUrl, request.clone());
+    }
+    catch {
+        try {
+            return new Request(targetUrl, request);
+        }
+        catch {
+            return request;
+        }
+    }
+}
 /**
  * Creates a mock AsyncLocalStorage implementation for environments where
  * native AsyncLocalStorage is not available or disabled.
  *
  * This mock implementation mimics the behavior of the native AsyncLocalStorage
- * but doesn't require the async_hooks module. It's designed to be used in
- * environments like Cloudflare Workers where AsyncLocalStorage is not available.
+ * but doesn't require the async_hooks module. It's used as a fallback when
+ * the runtime does not expose AsyncLocalStorage or when it has been disabled.
  *
  * @returns {import("./runtime.js").ParaglideAsyncLocalStorage}
  */