rune-lab 0.0.19 → 0.0.21

package/dist/paraglide/runtime.js

@@ -37,6 +37,18 @@ export const strategy = [
   "globalVariable",
   "baseLocale"
 ];
+/**
+ * Route-level strategy overrides.
+ *
+ * `match` uses URLPattern syntax.
+ *
+ * @type {Array<{
+ *   match: string;
+ *   strategy?: Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>;
+ *   exclude?: boolean;
+ * }>}
+ */
+export const routeStrategies = [];
 /**
  * The used URL patterns.
  *
@@ -101,6 +113,63 @@ export const urlPatterns = [
     ]
   }
 ];
+/** @type {string | undefined} */
+let cachedRouteStrategyUrl;
+/** @type {{ match: string; strategy?: Array<string>; exclude?: boolean } | undefined} */
+let cachedRouteStrategy;
+/**
+ * @param {string | URL} url
+ * @returns {{ match: string; strategy?: Array<string>; exclude?: boolean } | undefined}
+ */
+function findMatchingRouteStrategy(url) {
+    if (routeStrategies.length === 0) {
+        return undefined;
+    }
+    const urlString = typeof url === "string" ? url : url.href;
+    if (cachedRouteStrategyUrl === urlString) {
+        return cachedRouteStrategy;
+    }
+    const urlObject = new URL(urlString, "http://dummy.com");
+    let match;
+    for (const routeStrategy of routeStrategies) {
+        const pattern = new URLPattern(routeStrategy.match, urlObject.href);
+        if (pattern.exec(urlObject.href)) {
+            match = routeStrategy;
+            break;
+        }
+    }
+    cachedRouteStrategyUrl = urlString;
+    cachedRouteStrategy = match;
+    return match;
+}
+/**
+ * Returns the strategy to use for a specific URL.
+ *
+ * If no route strategy matches (or the matching rule is `exclude: true`),
+ * the global strategy is returned.
+ *
+ * @param {string | URL} url
+ * @returns {typeof strategy}
+ */
+export function getStrategyForUrl(url) {
+    const routeStrategy = findMatchingRouteStrategy(url);
+    if (routeStrategy &&
+        routeStrategy.exclude !== true &&
+        Array.isArray(routeStrategy.strategy)) {
+        // @ts-ignore - runtime value is injected and validated by compiler types.
+        return routeStrategy.strategy;
+    }
+    return strategy;
+}
+/**
+ * Returns whether the given URL is excluded from middleware i18n processing.
+ *
+ * @param {string | URL} url
+ * @returns {boolean}
+ */
+export function isExcludedByRouteStrategy(url) {
+    return findMatchingRouteStrategy(url)?.exclude === true;
+}
 /**
  * @typedef {{
  * 		getStore(): {
@@ -182,8 +251,6 @@ export let getLocale = () => {
     if (experimentalStaticLocale !== undefined) {
         return assertIsLocale(experimentalStaticLocale);
     }
-    /** @type {string | undefined} */
-    let locale;
     // if running in a server-side rendering context
     // retrieve the locale from the async local storage
     if (serverAsyncLocalStorage) {
@@ -192,7 +259,48 @@ export let getLocale = () => {
             return locale;
         }
     }
-    for (const strat of strategy) {
+    let strategyToUse = strategy;
+    if (!isServer && typeof window !== "undefined" && window.location?.href) {
+        strategyToUse = getStrategyForUrl(window.location.href);
+    }
+    const resolved = resolveLocaleWithStrategies(strategyToUse, typeof window !== "undefined" ? window.location?.href : undefined);
+    if (resolved) {
+        if (!localeInitiallySet) {
+            _locale = resolved;
+            // https://github.com/opral/inlang-paraglide-js/issues/455
+            localeInitiallySet = true;
+            setLocale(resolved, { reload: false });
+        }
+        return resolved;
+    }
+    throw new Error("No locale found. Read the docs https://inlang.com/m/gerre34r/library-inlang-paraglideJs/errors#no-locale-found");
+};
+/**
+ * Resolve locale for a given URL using route-aware strategies.
+ *
+ * @param {string | URL} url
+ * @returns {Locale}
+ */
+export function getLocaleForUrl(url) {
+    if (experimentalStaticLocale !== undefined) {
+        return assertIsLocale(experimentalStaticLocale);
+    }
+    const strategyToUse = getStrategyForUrl(url);
+    const resolved = resolveLocaleWithStrategies(strategyToUse, typeof url === "string" ? url : url.href);
+    if (resolved) {
+        return resolved;
+    }
+    throw new Error("No locale found. Read the docs https://inlang.com/m/gerre34r/library-inlang-paraglideJs/errors#no-locale-found");
+}
+/**
+ * @param {typeof strategy} strategyToUse
+ * @param {string | undefined} urlForUrlStrategy
+ * @returns {Locale | undefined}
+ */
+function resolveLocaleWithStrategies(strategyToUse, urlForUrlStrategy) {
+    /** @type {string | undefined} */
+    let locale;
+    for (const strat of strategyToUse) {
         if (TREE_SHAKE_COOKIE_STRATEGY_USED && strat === "cookie") {
             locale = extractLocaleFromCookie();
         }
@@ -202,8 +310,8 @@ export let getLocale = () => {
         else if (TREE_SHAKE_URL_STRATEGY_USED &&
             strat === "url" &&
             !isServer &&
-            typeof window !== "undefined") {
-            locale = extractLocaleFromUrl(window.location.href);
+            typeof urlForUrlStrategy === "string") {
+            locale = extractLocaleFromUrl(urlForUrlStrategy);
         }
         else if (TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED &&
             strat === "globalVariable" &&
@@ -232,20 +340,12 @@ export let getLocale = () => {
                 locale = result;
             }
         }
-        // check if match, else continue loop
         if (locale !== undefined) {
-            const asserted = assertIsLocale(locale);
-            if (!localeInitiallySet) {
-                _locale = asserted;
-                // https://github.com/opral/inlang-paraglide-js/issues/455
-                localeInitiallySet = true;
-                setLocale(asserted, { reload: false });
-            }
-            return asserted;
+            return assertIsLocale(locale);
         }
     }
-    throw new Error("No locale found. Read the docs https://inlang.com/m/gerre34r/library-inlang-paraglideJs/errors#no-locale-found");
-};
+    return undefined;
+}
 /**
  * Overwrite the `getLocale()` function.
  *
@@ -324,7 +424,11 @@ export let setLocale = (newLocale, options) => {
     const customSetLocalePromises = [];
     /** @type {string | undefined} */
     let newLocation = undefined;
-    for (const strat of strategy) {
+    let strategyToUse = strategy;
+    if (!isServer && typeof window !== "undefined" && window.location?.href) {
+        strategyToUse = getStrategyForUrl(window.location.href);
+    }
+    for (const strat of strategyToUse) {
         if (TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED &&
             strat === "globalVariable") {
             // a default for a custom strategy to get started quickly
@@ -507,9 +611,19 @@ export function assertIsLocale(input) {
  * @type {(request: Request) => Locale}
  */
 export const extractLocaleFromRequest = (request) => {
+    return extractLocaleFromRequestWithStrategies(request, getStrategyForUrl(request.url));
+};
+/**
+ * Extracts a locale from a request using the provided strategy order.
+ *
+ * @param {Request} request
+ * @param {typeof strategy} strategies
+ * @returns {Locale}
+ */
+export const extractLocaleFromRequestWithStrategies = (request, strategies) => {
     /** @type {string|undefined} */
     let locale;
-    for (const strat of strategy) {
+    for (const strat of strategies) {
         if (TREE_SHAKE_COOKIE_STRATEGY_USED && strat === "cookie") {
             locale = request.headers
                 .get("cookie")
@@ -582,6 +696,7 @@ export const extractLocaleFromRequest = (request) => {
 export const extractLocaleFromRequestAsync = async (request) => {
     /** @type {string|undefined} */
     let locale;
+    const strategy = getStrategyForUrl(request.url);
     // Process custom strategies first, in order
     for (const strat of strategy) {
         if (isCustomStrategy(strat) && customServerStrategies.has(strat)) {
@@ -597,7 +712,7 @@ export const extractLocaleFromRequestAsync = async (request) => {
         }
     }
     // If no custom strategy provided a valid locale, fall back to sync version
-    locale = extractLocaleFromRequest(request);
+    locale = extractLocaleFromRequestWithStrategies(request, strategy);
     return assertIsLocale(locale);
 };
 
@@ -1128,11 +1243,12 @@ export function aggregateGroups(match) {
  * @returns {Promise<ShouldRedirectResult>}
  */
 export async function shouldRedirect(input = {}) {
-    const locale = /** @type {ReturnType<typeof assertIsLocale>} */ (await resolveLocale(input));
-    if (!strategy.includes("url")) {
+    const currentUrl = resolveUrl(input);
+    const locale = /** @type {ReturnType<typeof assertIsLocale>} */ (await resolveLocale(input, currentUrl));
+    const strategy = getStrategyForUrl(currentUrl.href);
+    if (isExcludedByRouteStrategy(currentUrl.href) || !strategy.includes("url")) {
         return { shouldRedirect: false, locale, redirectUrl: undefined };
     }
-    const currentUrl = resolveUrl(input);
     const localizedUrl = localizeUrl(currentUrl.href, { locale });
     const shouldRedirectToLocalizedUrl = normalizeUrl(localizedUrl.href) !== normalizeUrl(currentUrl.href);
     return {
@@ -1145,15 +1261,19 @@ export async function shouldRedirect(input = {}) {
  * Resolves the locale either from the provided input or by using the configured strategies.
  *
  * @param {ShouldRedirectInput} input
+ * @param {URL} currentUrl
  * @returns {Promise<ReturnType<typeof assertIsLocale>>}
  */
-async function resolveLocale(input) {
+async function resolveLocale(input, currentUrl) {
     if (input.locale) {
         return assertIsLocale(input.locale);
     }
     if (input.request) {
         return extractLocaleFromRequestAsync(input.request);
     }
+    if (typeof input.url !== "undefined") {
+        return getLocaleForUrl(currentUrl.href);
+    }
     return getLocale();
 }
 /**

package/dist/paraglide/server.js

@@ -106,6 +106,15 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     } 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;
@@ -117,7 +126,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, {
@@ -137,22 +146,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")) {
+    if (strategy.includes("url")) {
         newRequest = new Request(runtime.deLocalizeUrl(request.url), request);
     }
     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);
     }
     // the message functions that have been called in this request
     /** @type {Set<string>} */
@@ -185,6 +183,31 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     }
     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.

package/dist/persistence/drivers.d.ts

@@ -0,0 +1,10 @@
+import type { PersistenceDriver } from "./types";
+export declare function createInMemoryDriver(): PersistenceDriver;
+export declare const inMemoryDriver: PersistenceDriver;
+export declare const localStorageDriver: PersistenceDriver;
+export declare const sessionStorageDriver: PersistenceDriver;
+export declare const cookieDriver: (options?: {
+    path?: string;
+    maxAge?: number;
+    sameSite?: "Lax" | "Strict" | "None";
+}) => PersistenceDriver;

package/dist/persistence/drivers.js

@@ -0,0 +1,71 @@
+export function createInMemoryDriver() {
+    const store = new Map();
+    return {
+        get: (key) => store.get(key) ?? null,
+        set: (key, value) => store.set(key, value),
+        remove: (key) => store.delete(key),
+    };
+}
+export const inMemoryDriver = createInMemoryDriver();
+export const localStorageDriver = {
+    get: (key) => {
+        if (typeof window === "undefined")
+            return null;
+        return window.localStorage.getItem(key);
+    },
+    set: (key, value) => {
+        if (typeof window === "undefined")
+            return;
+        window.localStorage.setItem(key, value);
+    },
+    remove: (key) => {
+        if (typeof window === "undefined")
+            return;
+        window.localStorage.removeItem(key);
+    },
+};
+export const sessionStorageDriver = {
+    get: (key) => {
+        if (typeof window === "undefined")
+            return null;
+        return window.sessionStorage.getItem(key);
+    },
+    set: (key, value) => {
+        if (typeof window === "undefined")
+            return;
+        window.sessionStorage.setItem(key, value);
+    },
+    remove: (key) => {
+        if (typeof window === "undefined")
+            return;
+        window.sessionStorage.removeItem(key);
+    },
+};
+export const cookieDriver = (options = {}) => ({
+    get: (key) => {
+        if (typeof window === "undefined" || typeof document === "undefined") {
+            return null;
+        }
+        const match = document.cookie.match(new RegExp(`(^| )${key}=([^;]+)`));
+        return match ? decodeURIComponent(match[2]) : null;
+    },
+    set: (key, value) => {
+        if (typeof window === "undefined" || typeof document === "undefined") {
+            return;
+        }
+        let cookie = `${key}=${encodeURIComponent(value)}`;
+        if (options.path)
+            cookie += `; path=${options.path}`;
+        if (options.maxAge)
+            cookie += `; max-age=${options.maxAge}`;
+        if (options.sameSite)
+            cookie += `; samesite=${options.sameSite}`;
+        document.cookie = cookie;
+    },
+    remove: (key) => {
+        if (typeof window === "undefined" || typeof document === "undefined") {
+            return;
+        }
+        document.cookie = `${key}=; max-age=0; path=${options.path || "/"}`;
+    },
+});

package/dist/persistence/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Synchronous persistence driver interface for Svelte stores
+ */
+export interface PersistenceDriver {
+    /**
+     * Get a value by key. Should return null if not found.
+     */
+    get(key: string): string | null;
+    /**
+     * Set a value by key.
+     */
+    set(key: string, value: string): void;
+    /**
+     * Remove a value by key.
+     */
+    remove(key: string): void;
+}

package/dist/persistence/types.js

@@ -0,0 +1,2 @@
+// src/lib/persistence/types.ts
+export {};

package/dist/showcase/AppStateInspector.svelte

@@ -1,7 +1,22 @@
 <script lang="ts">
-    import { appConfig } from "../config";
     import * as m from "../paraglide/messages.js";
     import StoreDetailCard from "./StoreDetailCard.svelte";
+    import { getAppStore } from "../state/app.svelte";
+    import { getApiStore } from "../state/api.svelte";
+    import { getThemeStore } from "../state/theme.svelte";
+    import { getLanguageStore } from "../state/language.svelte";
+    import { getCurrencyStore } from "../state/currency.svelte";
+    import { getToastStore } from "../state/toast.svelte";
+    import { getCommandStore } from "../state/commands.svelte";
+
+    // Inject context stores
+    const appStore = getAppStore();
+    const apiStore = getApiStore();
+    const themeStore = getThemeStore();
+    const languageStore = getLanguageStore();
+    const currencyStore = getCurrencyStore();
+    const toastStore = getToastStore();
+    const commandStore = getCommandStore();
 
     const storeState = $derived([
         {
@@ -13,12 +28,12 @@
                 {
                     key: "Name",
                     labelKey: "name_label",
-                    value: appConfig.app.name,
+                    value: appStore.name,
                 },
                 {
                     key: "Version",
                     labelKey: "version_label",
-                    value: appConfig.app.version,
+                    value: appStore.version,
                 },
             ],
         },
@@ -31,7 +46,7 @@
                 {
                     key: "Theme",
                     labelKey: "current_theme",
-                    value: `${appConfig.theme.getProp("icon") || ""} ${appConfig.theme.current}`,
+                    value: `${themeStore.getProp("icon") || ""} ${themeStore.current}`,
                 },
             ],
         },
@@ -44,12 +59,12 @@
                 {
                     key: "Language",
                     labelKey: "current_language",
-                    value: `${appConfig.language.getProp("flag") || ""} ${appConfig.language.current}`,
+                    value: `${languageStore.getProp("flag") || ""} ${languageStore.current}`,
                 },
                 {
                     key: "Currency",
                     labelKey: "current_currency",
-                    value: `${appConfig.currency.getProp("symbol") || ""} ${appConfig.currency.current}`,
+                    value: `${currencyStore.getProp("symbol") || ""} ${currencyStore.current}`,
                 },
             ],
         },
@@ -101,15 +116,15 @@
             </div>
             <div
                 class="stat-value capitalize {getStatusClass(
-                    appConfig.api.connectionState,
+                    apiStore.connectionState,
                 )} text-2xl"
             >
-                {appConfig.api.connectionState}
+                {apiStore.connectionState}
             </div>
             <div
                 class="stat-desc font-mono text-[10px] opacity-50 truncate max-w-[200px]"
             >
-                {appConfig.api.URL}
+                {apiStore.URL}
             </div>
         </div>
 
@@ -120,7 +135,7 @@
                 {t(m.active_toasts, "Active Toasts")}
             </div>
             <div class="stat-value text-2xl">
-                {appConfig.toast.toasts.length}
+                {toastStore.toasts.length}
             </div>
             <div class="stat-desc font-mono text-[10px] opacity-50">
                 {t(m.currently_in_queue, "Currently in queue")}
@@ -134,7 +149,7 @@
                 {t(m.commands_label, "Commands")}
             </div>
             <div class="stat-value text-2xl">
-                {appConfig.commands.commands.length}
+                {commandStore.commands.length}
             </div>
             <div class="stat-desc font-mono text-[10px] opacity-50">
                 {t(m.registered_in_registry, "Registered in registry")}

package/dist/showcase/Showcase.svelte

@@ -1,5 +1,8 @@
 <script lang="ts">
-  import { layoutStore } from "../state/layout.svelte";
+  import { getLayoutStore } from "../state/layout.svelte";
+
+  const layoutStore = getLayoutStore();
+
   import Actions from "./tabs/Actions.svelte";
   import DataInput from "./tabs/DataInput.svelte";
   import Display from "./tabs/Display.svelte";

package/dist/state/api.svelte.d.ts

@@ -2,7 +2,7 @@
  * API connection state and configuration
  */
 export type ConnectionState = "connected" | "connecting" | "disconnected";
-declare class ApiStore {
+export declare class ApiStore {
     url: string;
     version: string;
     connectionState: ConnectionState;
@@ -21,5 +21,5 @@ declare class ApiStore {
      */
     init(url: string, version?: string): void;
 }
-export declare const apiStore: ApiStore;
-export {};
+export declare function createApiStore(): ApiStore;
+export declare function getApiStore(): ApiStore;

package/dist/state/api.svelte.js

@@ -1,4 +1,6 @@
-class ApiStore {
+import { getContext } from "svelte";
+import { RUNE_LAB_CONTEXT } from "../context";
+export class ApiStore {
     // State
     url = $state("http://localhost:8000");
     version = $state("v1");
@@ -42,4 +44,9 @@ class ApiStore {
         this.reconnect();
     }
 }
-export const apiStore = new ApiStore();
+export function createApiStore() {
+    return new ApiStore();
+}
+export function getApiStore() {
+    return getContext(RUNE_LAB_CONTEXT.api);
+}

package/dist/state/app.svelte.d.ts

@@ -14,7 +14,7 @@ export interface AppData {
  * App Store
  * Manages application metadata and identity
  */
-declare class AppStore {
+export declare class AppStore {
     #private;
     name: string;
     version: string;
@@ -32,5 +32,5 @@ declare class AppStore {
      */
     get info(): AppData;
 }
-export declare const appStore: AppStore;
-export {};
+export declare function createAppStore(): AppStore;
+export declare function getAppStore(): AppStore;

package/dist/state/app.svelte.js

@@ -1,10 +1,11 @@
 // src/lib/stores/app-config.svelte.ts
-// SDK Package - Application Metadata Management
+import { getContext } from "svelte";
+import { RUNE_LAB_CONTEXT } from "../context";
 /**
  * App Store
  * Manages application metadata and identity
  */
-class AppStore {
+export class AppStore {
     // State
     name = $state("Rune Lab");
     version = $state("0.0.1");
@@ -18,8 +19,12 @@ class AppStore {
      * Initialize app store with metadata
      */
     init(data) {
-        if (this.#initialized)
+        if (this.#initialized) {
+            if (import.meta.env?.DEV) {
+                console.warn("AppStore.init() called multiple times. Ignoring subsequent calls.", "Overwritten properties would have been:", data);
+            }
             return;
+        }
         if (data.name)
             this.name = data.name;
         if (data.version)
@@ -52,4 +57,9 @@ class AppStore {
     }
 }
 // Export singleton instance
-export const appStore = new AppStore();
+export function createAppStore() {
+    return new AppStore();
+}
+export function getAppStore() {
+    return getContext(RUNE_LAB_CONTEXT.app);
+}