@turnipxenon/pineapple 4.5.0 → 4.5.1

package/dist/external/paraglide/server.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Server middleware that handles locale-based routing and request processing.
+ *
+ * This middleware performs several key functions:
+ *
+ * 1. Determines the locale for the incoming request using configured strategies
+ * 2. Handles URL localization and redirects (only for document requests)
+ * 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+ *
+ * When URL strategy is used:
+ *
+ * - The locale is extracted from the URL for all request types
+ * - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+ * - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+ *
+ * @template T - The return type of the resolve function
+ *
+ * @param {Request} request - The incoming request object
+ * @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request
+ *
+ * @returns {Promise<Response>}
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+ * export const handle = async ({ event, resolve }) => {
+ *   return serverMiddleware(event.request, ({ request, locale }) => {
+ *     // let the framework further resolve the request
+ *     return resolve(request);
+ *   });
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in a framework like Express JS or Hono
+ * app.use(async (req, res, next) => {
+ *   const result = await serverMiddleware(req, ({ request, locale }) => {
+ *     // If a redirect happens this won't be called
+ *     return next(request);
+ *   });
+ * });
+ * ```
+ *
+ * @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 serverMiddleware(
+ *       request,
+ *       ({ request, locale }) => handleRequest(request, locale),
+ *       { disableAsyncLocalStorage: true }
+ *     );
+ *   }
+ * };
+ * ```
+ */
+export function paraglideMiddleware<T>(request: Request, resolve: (args: {
+    request: Request;
+    locale: import("./runtime.js").Locale;
+}) => T | Promise<T>): Promise<Response>;

package/dist/external/paraglide/server.js

@@ -0,0 +1,174 @@
+// eslint-disable
+
+import * as runtime from "./runtime.js";
+
+/**
+ * Server middleware that handles locale-based routing and request processing.
+ *
+ * This middleware performs several key functions:
+ *
+ * 1. Determines the locale for the incoming request using configured strategies
+ * 2. Handles URL localization and redirects (only for document requests)
+ * 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+ *
+ * When URL strategy is used:
+ *
+ * - The locale is extracted from the URL for all request types
+ * - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+ * - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+ *
+ * @template T - The return type of the resolve function
+ *
+ * @param {Request} request - The incoming request object
+ * @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request
+ *
+ * @returns {Promise<Response>}
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+ * export const handle = async ({ event, resolve }) => {
+ *   return serverMiddleware(event.request, ({ request, locale }) => {
+ *     // let the framework further resolve the request
+ *     return resolve(request);
+ *   });
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in a framework like Express JS or Hono
+ * app.use(async (req, res, next) => {
+ *   const result = await serverMiddleware(req, ({ request, locale }) => {
+ *     // If a redirect happens this won't be called
+ *     return next(request);
+ *   });
+ * });
+ * ```
+ *
+ * @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 serverMiddleware(
+ *       request,
+ *       ({ request, locale }) => handleRequest(request, locale),
+ *       { disableAsyncLocalStorage: true }
+ *     );
+ *   }
+ * };
+ * ```
+ */
+export async function paraglideMiddleware(request, resolve) {
+    if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
+        const { AsyncLocalStorage } = await import("async_hooks");
+        runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+    }
+    else if (!runtime.serverAsyncLocalStorage) {
+        runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
+    }
+    const locale = runtime.extractLocaleFromRequest(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
+    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)) {
+            return Response.redirect(localizedUrl, 307);
+        }
+    }
+    // If the strategy includes "url", we need to de-localize the URL
+    // before passing it to the server middleware.
+    //
+    // The middleware is responsible for mapping a localized URL to the
+    // de-localized URL e.g. `/en/about` to `/about`. Otherwise,
+    // the server can't render the correct page.
+    const newRequest = runtime.strategy.includes("url")
+        ? new Request(runtime.deLocalizeUrl(request.url), request)
+        : // need to create a new request object because some metaframeworks (nextjs!) throw otherwise
+            // https://github.com/opral/inlang-paraglide-js/issues/411
+            new Request(request);
+    // the message functions that have been called in this request
+    /** @type {Set<string>} */
+    const messageCalls = new Set();
+    const response = await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest }));
+    // Only modify HTML responses
+    if (runtime.experimentalMiddlewareLocaleSplitting &&
+        response.headers.get("Content-Type")?.includes("html")) {
+        const body = await response.text();
+        const messages = [];
+        // using .values() to avoid polyfilling in older projects. else the following error is thrown
+        // Type 'Set<string>' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.
+        for (const messageCall of Array.from(messageCalls)) {
+            const [id, locale] = 
+            /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
+            messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
+        }
+        const script = `<script>globalThis.__paraglide_ssr = { ${messages.join(",")} }</script>`;
+        // Insert the script before the closing head tag
+        const newBody = body.replace("</head>", `${script}</head>`);
+        // Create a new response with the modified body
+        // Clone all headers except Content-Length which will be set automatically
+        const newHeaders = new Headers(response.headers);
+        newHeaders.delete("Content-Length"); // Let the browser calculate the correct length
+        return new Response(newBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
+        });
+    }
+    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.
+ *
+ * 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.
+ *
+ * @returns {import("./runtime.js").ParaglideAsyncLocalStorage}
+ */
+function createMockAsyncLocalStorage() {
+    /** @type {any} */
+    let currentStore = undefined;
+    return {
+        getStore() {
+            return currentStore;
+        },
+        async run(store, callback) {
+            currentStore = store;
+            try {
+                return await callback();
+            }
+            finally {
+                currentStore = undefined;
+            }
+        },
+    };
+}
+/**
+ * The compiled messages for the server middleware.
+ *
+ * Only populated if `enableMiddlewareOptimizations` is set to `true`.
+ *
+ * @type {Record<string, Record<import("./runtime.js").Locale, string>>}
+ */
+const compiledBundles = {};

package/dist/ui/elements/pinya-combobox/PinyaCombobox.svelte

@@ -1,10 +1,9 @@
 <script lang="ts" generics="T extends string">
-	import { Combobox } from '@skeletonlabs/skeleton-svelte';
-	import { getLocale, localizeHref } from '../../../paraglide/runtime';
 	import type { PinyaComboboxProps, ValueChangeDetails } from "./PinyaComboboxProps";
+	import { Combobox } from "@skeletonlabs/skeleton-svelte";
 
 	let {
-		contentZIndex = 'auto',
+		contentZIndex = "auto",
 		value = $bindable(),
 		onValueChange = () => {},
 		onValueChangeBase = undefined,
@@ -32,4 +31,4 @@
 	onValueChange={onValueChangeBase ?? onValueChangeBaseImpl}
 	{value}
 	{...props}
-/>
+/>

package/dist/ui/modules/NavigationMenu/NavigationMenu.svelte

@@ -8,7 +8,7 @@
 		type ParsePageMetaCompareFn
 	} from "./PageMeta";
 	import { PinyaCard } from "../../elements/index";
-	import { localizeHref } from "../../../paraglide/runtime.js";
+	import { localizeHref } from "../../../external/paraglide/runtime.js";
 
 	interface Props {
 		fileList: Record<string, unknown>;

package/dist/ui/modules/modals/general-settings/GeneralSettingsModal.svelte

@@ -2,7 +2,7 @@
 	import type { ModalProps } from 'svelte-modals';
 	import { setMode, userPrefersMode } from 'mode-watcher';
 
-	import { m } from '../../../../paraglide/messages';
+	import { m } from '../../../../external/paraglide/messages';
 	import ModalBase from '../../../components/ModalBase.svelte';
 	import DarkIcon from '../../../../assets/icons/icon-dark-mode.svg';
 	import LightIcon from '../../../../assets/icons/icon-light-mode.svg';
@@ -107,4 +107,4 @@
         text-align: start;
         gap: 1lh;
     }
-</style>
+</style>

package/dist/ui/modules/modals/general-settings/LanguagePicker.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { deLocalizeHref, getLocale, localizeHref } from "../../../../paraglide/runtime";
+	import { deLocalizeHref, getLocale, localizeHref } from "../../../../external/paraglide/runtime";
 	import PinyaCombobox from "../../../elements/pinya-combobox/PinyaCombobox.svelte";
 	import { appState } from "../../../templates/PinyaPageLayout/runes.svelte";
 
@@ -40,4 +40,4 @@
 	placeholder="Select Language"
 	{onValueChange}
 	{disabled}
-/>
+/>

package/dist/ui/templates/PinyaBase.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { page } from "$app/state";
-	import { locales, localizeHref } from "../../paraglide/runtime";
+	import { locales, localizeHref } from "../../external/paraglide/runtime";
 	import "../../styles/global.css";
 	import WebThumbnailImage from "../../assets/placeholder/placeholder_circle.png";
 	import type { PinyaHead } from "./runes.svelte";

package/dist/ui/templates/PinyaPageLayout/PinyaPageLayout.svelte

@@ -1,8 +1,8 @@
 <script lang="ts">
 	import type { Snippet } from "svelte";
 	import { modals } from "svelte-modals";
-	import { m } from "../../../paraglide/messages";
-	import { localizeHref } from "../../../paraglide/runtime";
+	import { m } from "../../../external/paraglide/messages";
+	import { localizeHref } from "../../../external/paraglide/runtime";
 
 	import AresLogo from "../../../assets/characters/ares/ares_logo.webp";
 	import SettingsLogo from "../../../assets/icons/icon-settings.svg";
@@ -121,4 +121,4 @@
         width: 100%;
         height: calc(var(--dialog-box-height) + 3.5lh);
     }
-</style>
+</style>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@turnipxenon/pineapple",
   "description": "personal package for base styling for other personal projects",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "scripts": {
     "dev": "vite dev",
     "build": "vite build",