rune-lab 0.3.1 → 0.4.1

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

@@ -1,103 +0,0 @@
-/**
- * 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`)
- *
- * @see https://inlang.com/m/gerre34r/library-inlang-paraglideJs/middleware
- *
- * @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. The callback receives:
- *   - `request`: A modified request with a delocalized URL when the URL strategy is used (e.g., `/fr/about` → `/about`).
- *      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
- * @returns {Promise<Response>}
- *
- * @example
- * ```typescript
- * // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
- * export const handle = async ({ event, resolve }) => {
- *   return paraglideMiddleware(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 paraglideMiddleware(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 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
- * // themselves via their own rewrite APIs (e.g., `rewrite.input`/`rewrite.output`).
- * //
- * // When the framework handles this, the middleware's URL delocalization is not needed.
- * // Using the modified `request` from the callback would cause a redirect loop because
- * // both the middleware and the framework would attempt to delocalize the URL.
- * //
- * // Solution: Pass the original request to the handler instead of the modified one.
- * // The middleware still handles locale detection, cookies, and AsyncLocalStorage context.
- * //
- * // ❌ WRONG - causes redirect loop when framework handles URL rewriting:
- * // paraglideMiddleware(req, ({ request }) => handler.fetch(request))
- * //
- * // ✅ CORRECT - use original request when framework handles URL localization:
- * // paraglideMiddleware(req, () => handler.fetch(req))
- *
- * * *
- * export default {
- *   fetch(req: Request): Promise<Response> {
- *     // TanStack Router handles URL rewriting via deLocalizeUrl/localizeUrl
- *     // so we pass the original `req` instead of the modified `request`
- *     return paraglideMiddleware(req, () => handler.fetch(req))
- *   },
- * }
- * ```
- */
-export function paraglideMiddleware<T>(request: Request, resolve: (args: {
-    request: Request;
-    locale: import("./runtime.js").Locale;
-}) => T | Promise<T>, callbacks?: {
-    onRedirect: (response: Response) => void;
-}): Promise<Response>;

package/dist/ui/paraglide/server.js

@@ -1,248 +0,0 @@
-/* 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`)
- *
- * @see https://inlang.com/m/gerre34r/library-inlang-paraglideJs/middleware
- *
- * @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. The callback receives:
- *   - `request`: A modified request with a delocalized URL when the URL strategy is used (e.g., `/fr/about` → `/about`).
- *      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
- * @returns {Promise<Response>}
- *
- * @example
- * ```typescript
- * // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
- * export const handle = async ({ event, resolve }) => {
- *   return paraglideMiddleware(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 paraglideMiddleware(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 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
- * // themselves via their own rewrite APIs (e.g., `rewrite.input`/`rewrite.output`).
- * //
- * // When the framework handles this, the middleware's URL delocalization is not needed.
- * // Using the modified `request` from the callback would cause a redirect loop because
- * // both the middleware and the framework would attempt to delocalize the URL.
- * //
- * // Solution: Pass the original request to the handler instead of the modified one.
- * // The middleware still handles locale detection, cookies, and AsyncLocalStorage context.
- * //
- * // ❌ WRONG - causes redirect loop when framework handles URL rewriting:
- * // paraglideMiddleware(req, ({ request }) => handler.fetch(request))
- * //
- * // ✅ CORRECT - use original request when framework handles URL localization:
- * // paraglideMiddleware(req, () => handler.fetch(req))
- *
- * * *
- * export default {
- *   fetch(req: Request): Promise<Response> {
- *     // TanStack Router handles URL rewriting via deLocalizeUrl/localizeUrl
- *     // so we pass the original `req` instead of the modified `request`
- *     return paraglideMiddleware(req, () => handler.fetch(req))
- *   },
- * }
- * ```
- */
-export async function paraglideMiddleware(request, resolve, callbacks) {
-    if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
-      const { AsyncLocalStorage } = await import("async_hooks");
-      runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
-    } else if (!runtime.serverAsyncLocalStorage) {
-      runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
-    }
-    if (runtime.isExcludedByRouteStrategy(request.url)) {
-        const locale = runtime.baseLocale;
-        const origin = new URL(request.url).origin;
-        const newRequest = cloneRequestWithFallback(request);
-        /** @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(request.url);
-    const decision = await runtime.shouldRedirect({ request });
-    const locale = decision.locale;
-    const origin = new URL(request.url).origin;
-    // if the client makes a request to a URL that doesn't match
-    // the localizedUrl, redirect the client to the localized URL
-    if (request.headers.get("Sec-Fetch-Dest") === "document" &&
-        decision.shouldRedirect &&
-        decision.redirectUrl) {
-        // Create headers object with Vary header if preferredLanguage strategy is used
-        /** @type {Record<string, string>} */
-        const headers = {};
-        if (strategy.includes("preferredLanguage")) {
-            headers["Vary"] = "Accept-Language";
-        }
-        const response = new Response(null, {
-            status: 307,
-            headers: {
-                Location: decision.redirectUrl.href,
-                ...headers,
-            },
-        });
-        callbacks?.onRedirect(response);
-        return response;
-    }
-    // If the strategy includes "url", we need to de-localize the URL
-    // before passing it to the server middleware.
-    //
-    // 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.
-    let newRequest;
-    if (strategy.includes("url")) {
-        newRequest = new Request(runtime.deLocalizeUrl(request.url), request);
-    }
-    else {
-        newRequest = cloneRequestWithFallback(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;
-}
-/**
- * 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
- *
- * @param {Request} request
- * @returns {Request}
- */
-function cloneRequestWithFallback(request) {
-    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;
-        }
-    }
-}
-/**
- * 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;
-            }
-        },
-    };
-}
-// Used in generated server.js when async local storage is disabled.
-void createMockAsyncLocalStorage;
-/**
- * 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/primitives/DatePicker.svelte

@@ -1,257 +0,0 @@
-<!--
-  DatePicker — Locale-aware calendar grid primitive.
-  Reads LanguageStore from context for weekday/month names.
-  Zero domain knowledge.
--->
-<script module lang="ts">
-    export interface DatePickerProps {
-        /** Currently selected date */
-        value?: Date | string;
-        /** Disabled dates (cannot be selected) */
-        disabledDates?: Date[];
-        /** Highlighted dates (visual emphasis) */
-        highlightedDates?: Date[];
-        /** Minimum selectable date */
-        minDate?: Date;
-        /** Maximum selectable date */
-        maxDate?: Date;
-        /** Fired when a date is selected */
-        onchange?: (date: Date) => void;
-    }
-</script>
-
-<script lang="ts">
-    import { getLanguageStore } from "rune-lab/state";
-    import { untrack } from "svelte";
-
-    let {
-        value,
-        disabledDates = [],
-        highlightedDates = [],
-        minDate,
-        maxDate,
-        onchange,
-    }: DatePickerProps = $props();
-
-    const languageStore = getLanguageStore();
-
-    // Parse initial value
-    function parseDate(d?: Date | string): Date {
-        if (!d) return new Date();
-        return typeof d === "string" ? new Date(d) : d;
-    }
-
-    // Capture the initial value once to avoid state_referenced_locally warnings
-    const initialDate = untrack(() => parseDate(value));
-
-    let selectedDate = $state(initialDate);
-    let viewYear = $state(initialDate.getFullYear());
-    let viewMonth = $state(initialDate.getMonth());
-
-    // Locale-aware formatting
-    const locale = $derived(String(languageStore.current) || "en");
-
-    const weekdayNames = $derived(
-        Array.from({ length: 7 }, (_, i) => {
-            const d = new Date(2024, 0, i + 1); // Mon=1 Jan 2024
-            return new Intl.DateTimeFormat(locale, { weekday: "short" }).format(
-                d,
-            );
-        }),
-    );
-
-    const monthName = $derived(
-        new Intl.DateTimeFormat(locale, { month: "long" }).format(
-            new Date(viewYear, viewMonth),
-        ),
-    );
-
-    // Calendar grid
-    const calendarDays = $derived.by(() => {
-        const firstDay = new Date(viewYear, viewMonth, 1);
-        const lastDay = new Date(viewYear, viewMonth + 1, 0);
-        const startOffset = (firstDay.getDay() + 6) % 7; // Monday-based
-        const totalDays = lastDay.getDate();
-
-        const days: (number | null)[] = [];
-
-        // Leading empty slots
-        for (let i = 0; i < startOffset; i++) days.push(null);
-        // Actual days
-        for (let d = 1; d <= totalDays; d++) days.push(d);
-
-        return days;
-    });
-
-    const today = new Date();
-    const todayStr = `${today.getFullYear()}-${today.getMonth()}-${today.getDate()}`;
-
-    function dateKey(year: number, month: number, day: number): string {
-        return `${year}-${month}-${day}`;
-    }
-
-    const disabledSet = $derived(
-        new Set(
-            disabledDates.map((d) =>
-                dateKey(d.getFullYear(), d.getMonth(), d.getDate()),
-            ),
-        ),
-    );
-
-    const highlightedSet = $derived(
-        new Set(
-            highlightedDates.map((d) =>
-                dateKey(d.getFullYear(), d.getMonth(), d.getDate()),
-            ),
-        ),
-    );
-
-    function isDisabled(day: number): boolean {
-        const k = dateKey(viewYear, viewMonth, day);
-        if (disabledSet.has(k)) return true;
-        const d = new Date(viewYear, viewMonth, day);
-        if (minDate && d < minDate) return true;
-        if (maxDate && d > maxDate) return true;
-        return false;
-    }
-
-    function isSelected(day: number): boolean {
-        return (
-            selectedDate.getFullYear() === viewYear &&
-            selectedDate.getMonth() === viewMonth &&
-            selectedDate.getDate() === day
-        );
-    }
-
-    function isToday(day: number): boolean {
-        return dateKey(viewYear, viewMonth, day) === todayStr;
-    }
-
-    function isHighlighted(day: number): boolean {
-        return highlightedSet.has(dateKey(viewYear, viewMonth, day));
-    }
-
-    function selectDay(day: number) {
-        if (isDisabled(day)) return;
-        selectedDate = new Date(viewYear, viewMonth, day);
-        onchange?.(selectedDate);
-    }
-
-    function prevMonth() {
-        if (viewMonth === 0) {
-            viewMonth = 11;
-            viewYear--;
-        } else {
-            viewMonth--;
-        }
-    }
-
-    function nextMonth() {
-        if (viewMonth === 11) {
-            viewMonth = 0;
-            viewYear++;
-        } else {
-            viewMonth++;
-        }
-    }
-
-    function handleKeydown(e: KeyboardEvent) {
-        const day = selectedDate.getDate();
-        let newDate: Date | null = null;
-
-        switch (e.key) {
-            case "ArrowLeft":
-                newDate = new Date(viewYear, viewMonth, day - 1);
-                break;
-            case "ArrowRight":
-                newDate = new Date(viewYear, viewMonth, day + 1);
-                break;
-            case "ArrowUp":
-                newDate = new Date(viewYear, viewMonth, day - 7);
-                break;
-            case "ArrowDown":
-                newDate = new Date(viewYear, viewMonth, day + 7);
-                break;
-            case "Enter":
-                selectDay(day);
-                return;
-            case "Escape":
-                (e.currentTarget as HTMLElement)?.blur();
-                return;
-            default:
-                return;
-        }
-
-        if (newDate) {
-            e.preventDefault();
-            selectedDate = newDate;
-            viewYear = newDate.getFullYear();
-            viewMonth = newDate.getMonth();
-        }
-    }
-</script>
-
-<!-- svelte-ignore a11y_no_noninteractive_tabindex -->
-<div
-    class="rl-datepicker inline-flex flex-col gap-2 p-4 rounded-box bg-base-200 border border-base-content/10 select-none"
-    tabindex="0"
-    role="grid"
-    aria-label="Date picker"
-    onkeydown={handleKeydown}
->
-    <!-- Header: Month/Year + Navigation -->
-    <div class="flex items-center justify-between">
-        <button
-            class="btn btn-ghost btn-sm btn-square"
-            onclick={prevMonth}
-            aria-label="Previous month"
-        >
-            ‹
-        </button>
-        <span class="font-semibold text-sm capitalize">
-            {monthName}
-            {viewYear}
-        </span>
-        <button
-            class="btn btn-ghost btn-sm btn-square"
-            onclick={nextMonth}
-            aria-label="Next month"
-        >
-            ›
-        </button>
-    </div>
-
-    <!-- Weekday Headers -->
-    <div class="grid grid-cols-7 gap-1 text-center">
-        {#each weekdayNames as wd}
-            <span class="text-xs text-base-content/50 font-medium">{wd}</span>
-        {/each}
-    </div>
-
-    <!-- Day Grid -->
-    <div class="grid grid-cols-7 gap-1">
-        {#each calendarDays as day}
-            {#if day === null}
-                <div></div>
-            {:else}
-                <button
-                    class="btn btn-sm btn-square text-xs transition-all duration-150"
-                    class:btn-primary={isSelected(day)}
-                    class:btn-ghost={!isSelected(day)}
-                    class:ring-2={isToday(day) && !isSelected(day)}
-                    class:ring-primary={isToday(day) && !isSelected(day)}
-                    class:btn-disabled={isDisabled(day)}
-                    class:opacity-30={isDisabled(day)}
-                    class:bg-accent={isHighlighted(day) && !isSelected(day)}
-                    class:bg-opacity-20={isHighlighted(day) && !isSelected(day)}
-                    onclick={() => selectDay(day)}
-                    disabled={isDisabled(day)}
-                    aria-label={`${day} ${monthName} ${viewYear}`}
-                    aria-pressed={isSelected(day)}
-                >
-                    {day}
-                </button>
-            {/if}
-        {/each}
-    </div>
-</div>

package/dist/ui/primitives/DatePicker.svelte.d.ts

@@ -1,17 +0,0 @@
-export interface DatePickerProps {
-    /** Currently selected date */
-    value?: Date | string;
-    /** Disabled dates (cannot be selected) */
-    disabledDates?: Date[];
-    /** Highlighted dates (visual emphasis) */
-    highlightedDates?: Date[];
-    /** Minimum selectable date */
-    minDate?: Date;
-    /** Maximum selectable date */
-    maxDate?: Date;
-    /** Fired when a date is selected */
-    onchange?: (date: Date) => void;
-}
-declare const DatePicker: import("svelte").Component<DatePickerProps, {}, "">;
-type DatePicker = ReturnType<typeof DatePicker>;
-export default DatePicker;

package/dist/ui/primitives/index.d.ts

@@ -1 +0,0 @@
-export { default as DatePicker } from "./DatePicker.svelte";

package/dist/ui/primitives/index.js

@@ -1,3 +0,0 @@
-// sdk/ui/src/lib/primitives/index.ts
-// Barrel export for primitive UI components
-export { default as DatePicker } from "./DatePicker.svelte";