rune-lab 0.3.0 → 0.4.0

package/dist/state/persistence/provider.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { resolveDriver } from "./provider.ts";
+describe("DriverProvider", () => {
+    describe("resolveDriver", () => {
+        it("should return inMemoryDriver when given undefined", () => {
+            const driver = resolveDriver(undefined);
+            expect(driver).toBeDefined();
+            expect(typeof driver.get).toBe("function");
+            expect(typeof driver.set).toBe("function");
+            expect(typeof driver.remove).toBe("function");
+        });
+        it("should pass through a concrete PersistenceDriver", () => {
+            const mockDriver = {
+                get: () => null,
+                set: () => { },
+                remove: () => { },
+            };
+            const driver = resolveDriver(mockDriver);
+            expect(driver).toBe(mockDriver);
+        });
+        it("should resolve a factory function to a concrete driver", () => {
+            const mockDriver = {
+                get: () => null,
+                set: () => { },
+                remove: () => { },
+            };
+            const driver = resolveDriver(() => mockDriver);
+            expect(driver).toBe(mockDriver);
+        });
+        it("should fall back to inMemoryDriver when factory returns undefined", () => {
+            const driver = resolveDriver(() => undefined);
+            expect(driver).toBeDefined();
+            expect(typeof driver.get).toBe("function");
+        });
+        it("inMemoryDriver fallback should be functional", () => {
+            const driver = resolveDriver(undefined);
+            driver.set("test-key", "test-value");
+            expect(driver.get("test-key")).toBe("test-value");
+            driver.remove("test-key");
+            expect(driver.get("test-key")).toBeNull();
+        });
+        it("should create isolated inMemoryDriver instances per call", () => {
+            const driverA = resolveDriver(undefined);
+            const driverB = resolveDriver(undefined);
+            driverA.set("key", "A");
+            driverB.set("key", "B");
+            expect(driverA.get("key")).toBe("A");
+            expect(driverB.get("key")).toBe("B");
+        });
+    });
+});

package/dist/state/registry/index.d.ts

@@ -0,0 +1,44 @@
+import type { StoreRegistryEntry } from "./types.ts";
+export type { StoreFactory, StoreRegistryEntry } from "./types.ts";
+/**
+ * The global store registry.
+ * Pre-populated with built-in stores by RuneProvider.
+ * Third-party plugins can register additional entries before mounting.
+ *
+ * @example
+ * ```ts
+ * // Plugin registration (before RuneProvider mounts)
+ * registerStore({
+ *   key: "analytics",
+ *   factory: (config, driver) => createAnalyticsStore(config),
+ *   optional: true,
+ *   noPersistence: true,
+ * });
+ * ```
+ */
+declare const STORE_REGISTRY: Map<string, StoreRegistryEntry<unknown, unknown>>;
+/**
+ * Register a store entry in the global registry.
+ * Must be called before RuneProvider mounts for the store to be auto-wired.
+ *
+ * @param entry - Store registry entry with key, factory, and options.
+ * @throws Error if a store with the same key is already registered.
+ */
+export declare function registerStore(entry: StoreRegistryEntry): void;
+/**
+ * Get a registered store entry by key.
+ */
+export declare function getRegisteredStore(key: string): StoreRegistryEntry | undefined;
+/**
+ * Get all registered store entries.
+ */
+export declare function getAllRegisteredStores(): Map<string, StoreRegistryEntry>;
+/**
+ * Remove a store registration (primarily useful for testing).
+ */
+export declare function unregisterStore(key: string): boolean;
+/**
+ * Clear all store registrations (primarily useful for testing).
+ */
+export declare function clearRegistry(): void;
+export { STORE_REGISTRY };

package/dist/state/registry/index.js

@@ -0,0 +1,58 @@
+// sdk/state/src/registry/index.ts
+// Store Registry — declarative map of context keys to store factories.
+// RuneProvider iterates this at mount time to auto-wire all stores.
+/**
+ * The global store registry.
+ * Pre-populated with built-in stores by RuneProvider.
+ * Third-party plugins can register additional entries before mounting.
+ *
+ * @example
+ * ```ts
+ * // Plugin registration (before RuneProvider mounts)
+ * registerStore({
+ *   key: "analytics",
+ *   factory: (config, driver) => createAnalyticsStore(config),
+ *   optional: true,
+ *   noPersistence: true,
+ * });
+ * ```
+ */
+const STORE_REGISTRY = new Map();
+/**
+ * Register a store entry in the global registry.
+ * Must be called before RuneProvider mounts for the store to be auto-wired.
+ *
+ * @param entry - Store registry entry with key, factory, and options.
+ * @throws Error if a store with the same key is already registered.
+ */
+export function registerStore(entry) {
+    if (STORE_REGISTRY.has(entry.key)) {
+        console.warn(`[StoreRegistry] Overwriting existing store registration for key "${entry.key}"`);
+    }
+    STORE_REGISTRY.set(entry.key, entry);
+}
+/**
+ * Get a registered store entry by key.
+ */
+export function getRegisteredStore(key) {
+    return STORE_REGISTRY.get(key);
+}
+/**
+ * Get all registered store entries.
+ */
+export function getAllRegisteredStores() {
+    return STORE_REGISTRY;
+}
+/**
+ * Remove a store registration (primarily useful for testing).
+ */
+export function unregisterStore(key) {
+    return STORE_REGISTRY.delete(key);
+}
+/**
+ * Clear all store registrations (primarily useful for testing).
+ */
+export function clearRegistry() {
+    STORE_REGISTRY.clear();
+}
+export { STORE_REGISTRY };

package/dist/state/registry/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/state/registry/registry.test.js

@@ -0,0 +1,112 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { registerStore, getRegisteredStore, getAllRegisteredStores, unregisterStore, clearRegistry, STORE_REGISTRY, } from "./index.ts";
+describe("StoreRegistry", () => {
+    // Clean slate for each test
+    beforeEach(() => {
+        clearRegistry();
+    });
+    describe("registerStore", () => {
+        it("should register a store entry", () => {
+            registerStore({
+                key: "test",
+                factory: () => ({ value: 42 }),
+            });
+            expect(STORE_REGISTRY.size).toBe(1);
+            expect(STORE_REGISTRY.has("test")).toBe(true);
+        });
+        it("should allow overwriting with a warning", () => {
+            registerStore({ key: "test", factory: () => "v1" });
+            registerStore({ key: "test", factory: () => "v2" });
+            expect(STORE_REGISTRY.size).toBe(1);
+            const entry = getRegisteredStore("test");
+            // Factory should be the second one
+            expect(entry?.factory({}, {})).toBe("v2");
+        });
+        it("should register multiple entries", () => {
+            registerStore({ key: "a", factory: () => "A" });
+            registerStore({ key: "b", factory: () => "B" });
+            registerStore({ key: "c", factory: () => "C" });
+            expect(STORE_REGISTRY.size).toBe(3);
+        });
+    });
+    describe("getRegisteredStore", () => {
+        it("should return the entry for a registered key", () => {
+            registerStore({
+                key: "theme",
+                factory: () => "theme-store",
+                optional: false,
+            });
+            const entry = getRegisteredStore("theme");
+            expect(entry).toBeDefined();
+            expect(entry.key).toBe("theme");
+            expect(entry.optional).toBe(false);
+        });
+        it("should return undefined for unregistered keys", () => {
+            expect(getRegisteredStore("nonexistent")).toBeUndefined();
+        });
+    });
+    describe("getAllRegisteredStores", () => {
+        it("should return all registered stores", () => {
+            registerStore({ key: "a", factory: () => "A" });
+            registerStore({ key: "b", factory: () => "B" });
+            const all = getAllRegisteredStores();
+            expect(all.size).toBe(2);
+            expect(all.has("a")).toBe(true);
+            expect(all.has("b")).toBe(true);
+        });
+    });
+    describe("unregisterStore", () => {
+        it("should remove a registered store", () => {
+            registerStore({ key: "test", factory: () => "val" });
+            expect(STORE_REGISTRY.has("test")).toBe(true);
+            const result = unregisterStore("test");
+            expect(result).toBe(true);
+            expect(STORE_REGISTRY.has("test")).toBe(false);
+        });
+        it("should return false for non-existent keys", () => {
+            expect(unregisterStore("nope")).toBe(false);
+        });
+    });
+    describe("clearRegistry", () => {
+        it("should remove all entries", () => {
+            registerStore({ key: "a", factory: () => "A" });
+            registerStore({ key: "b", factory: () => "B" });
+            expect(STORE_REGISTRY.size).toBe(2);
+            clearRegistry();
+            expect(STORE_REGISTRY.size).toBe(0);
+        });
+    });
+    describe("StoreFactory contract", () => {
+        it("factory receives config and driver, returns store", () => {
+            const mockDriver = {
+                get: () => null,
+                set: () => { },
+                remove: () => { },
+            };
+            registerStore({
+                key: "analytics",
+                factory: (config, driver) => ({
+                    type: "analytics",
+                    hasDriver: !!driver,
+                }),
+                optional: true,
+                noPersistence: true,
+            });
+            const entry = getRegisteredStore("analytics");
+            const store = entry.factory({ apiUrl: "test" }, mockDriver);
+            expect(store).toEqual({
+                type: "analytics",
+                hasDriver: true,
+            });
+        });
+        it("optional factory can return null", () => {
+            registerStore({
+                key: "optional-feature",
+                factory: () => null,
+                optional: true,
+            });
+            const entry = getRegisteredStore("optional-feature");
+            expect(entry.factory({}, {})).toBeNull();
+        });
+    });
+});

package/dist/state/registry/types.d.ts

@@ -0,0 +1,20 @@
+import type { PersistenceDriver } from "@internal/core";
+/**
+ * Factory function signature for creating a store.
+ * Receives the resolved config and driver, returns a store instance or null (for optional stores).
+ */
+export type StoreFactory<TConfig = unknown, TStore = unknown> = (config: TConfig, driver: PersistenceDriver) => TStore | null;
+/**
+ * An entry in the Store Registry.
+ * Maps a context key to its factory function and metadata.
+ */
+export interface StoreRegistryEntry<TConfig = unknown, TStore = unknown> {
+    /** Unique key matching the RUNE_LAB_CONTEXT key (e.g., "theme", "language") */
+    key: string;
+    /** Factory function that creates the store */
+    factory: StoreFactory<TConfig, TStore>;
+    /** If true, the store is optional — null return from factory means "skip" */
+    optional?: boolean;
+    /** If true, the store does not use persistence at all */
+    noPersistence?: boolean;
+}

package/dist/state/registry/types.js

@@ -0,0 +1,3 @@
+// sdk/state/src/registry/types.ts
+// Types for the Store Registry — the declarative store auto-wiring engine.
+export {};

package/dist/state/shortcuts.svelte.js

@@ -1,6 +1,6 @@
 import hotkeys from "hotkeys-js";
 import { getContext, untrack } from "svelte";
-import { RUNE_LAB_CONTEXT } from "./context";
+import { RUNE_LAB_CONTEXT } from "./context.ts";
 import { DEV } from "esm-env";
 /**
  * Built-in layout shortcuts
@@ -166,7 +166,7 @@ export function shortcutListener(node, shortcutStore) {
             for (const entry of shortcutStore.entries) {
                 if (entry.enabled === false)
                     continue;
-                hotkeys(entry.keys, "all", (event, handler) => {
+                hotkeys(entry.keys, "all", (event, _handler) => {
                     // Scoping logic: check if the event target is within the required scope
                     if (entry.scope === "global") {
                         // Hotkeys.js already filters inputs by default
@@ -202,9 +202,9 @@ export function shortcutListener(node, shortcutStore) {
                 hotkeys.setScope("global");
             }
         };
-        window.addEventListener("focusin", handleFocusIn);
+        globalThis.addEventListener("focusin", handleFocusIn);
         return () => {
-            window.removeEventListener("focusin", handleFocusIn);
+            globalThis.removeEventListener("focusin", handleFocusIn);
         };
     });
     return {

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

@@ -1,9 +1,9 @@
-import { type ConfigStore } from "./createConfigStore.svelte";
+import { type ConfigStore } from "./createConfigStore.svelte.ts";
 export interface Theme {
     name: string;
     icon: string;
 }
-import type { PersistenceDriver } from "rune-lab/core";
+import type { PersistenceDriver } from "@internal/core";
 export interface ThemeStoreOptions {
     driver?: PersistenceDriver | (() => PersistenceDriver | undefined);
     /** Additional custom themes to append to the built-in DaisyUI set */
@@ -11,12 +11,5 @@ export interface ThemeStoreOptions {
     /** Fallback theme if no persisted value exists (after system preference check) */
     defaultTheme?: string;
 }
-export declare function createThemeStore(driverOrOptions?: PersistenceDriver | (() => PersistenceDriver | undefined) | ThemeStoreOptions): {
-    current: string;
-    available: Theme[];
-    set(id: string): void;
-    get(id: string): Theme | undefined;
-    getProp<K extends keyof Theme>(prop: K, id?: string | undefined): Theme[K] | undefined;
-    addItems(newItems: Theme[]): void;
-};
+export declare function createThemeStore(driverOrOptions?: PersistenceDriver | (() => PersistenceDriver | undefined) | ThemeStoreOptions): ConfigStore<Theme>;
 export declare function getThemeStore(): ConfigStore<Theme>;

package/dist/state/theme.svelte.js

@@ -1,7 +1,8 @@
+// @ts-nocheck: legacy daisyui imports and complex ConfigStore typing
 // client/packages/ui/src/state/theme-config.svelte.ts
-import { createConfigStore, } from "./createConfigStore.svelte";
+import { createConfigStore, } from "./createConfigStore.svelte.ts";
 import { getContext } from "svelte";
-import { RUNE_LAB_CONTEXT } from "./context";
+import { RUNE_LAB_CONTEXT } from "./context.ts";
 // Icon map for known themes - unknown ones fall back to 🎨
 const THEME_ICONS = {
     light: "🌞",
@@ -40,13 +41,14 @@ const THEME_ICONS = {
     abyss: "🌌",
     silk: "🎀",
 };
+import { resolveDriver } from "./persistence/provider.ts";
+import themeOrder from "daisyui/functions/themeOrder.js";
+import { BROWSER } from "esm-env";
 // Derived from daisyUI directly — stays in sync automatically
 const THEMES = themeOrder.map((name) => ({
     name,
     icon: THEME_ICONS[name] ?? "🎨",
 }));
-import themeOrder from "daisyui/functions/themeOrder.js";
-import { BROWSER } from "esm-env";
 export function createThemeStore(driverOrOptions) {
     // Normalize overloaded argument
     const opts = driverOrOptions && typeof driverOrOptions === "object" &&
@@ -55,9 +57,7 @@ export function createThemeStore(driverOrOptions) {
         : {
             driver: driverOrOptions,
         };
-    const resolvedDriver = typeof opts.driver === "function"
-        ? opts.driver()
-        : opts.driver;
+    const resolvedDriver = resolveDriver(opts.driver);
     const store = createConfigStore({
         items: THEMES,
         storageKey: "theme",
@@ -72,7 +72,7 @@ export function createThemeStore(driverOrOptions) {
     }
     // System preference detection — only if no persisted value was loaded
     if (!resolvedDriver?.get("theme") && BROWSER) {
-        const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+        const prefersDark = globalThis.matchMedia("(prefers-color-scheme: dark)").matches;
         const systemDefault = prefersDark ? "dark" : "light";
         const chosen = opts.defaultTheme ?? systemDefault;
         if (store.get(chosen)) {

package/dist/state/toast-bridge.d.ts

@@ -1,4 +1,4 @@
-import type { ToastStore, ToastType } from "./toast.svelte";
+import type { ToastStore, ToastType } from "./toast.svelte.ts";
 /**
  * Notifies the global toast system.
  * If called before the ToastStore is initialized (e.g., in a module-level store),

package/dist/state/toast.svelte.js

@@ -1,5 +1,5 @@
 import { getContext } from "svelte";
-import { RUNE_LAB_CONTEXT } from "./context";
+import { RUNE_LAB_CONTEXT } from "./context.ts";
 export class ToastStore {
     toasts = $state([]);
     /**

package/dist/ui/components/ApiMonitor.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
-    import { getApiStore } from "rune-lab/state";
-    import { getToastStore } from "rune-lab/state";
+    import { getApiStore } from "@internal/state";
+    import { getToastStore } from "@internal/state";
 
     const apiStore = getApiStore();
     const toastStore = getToastStore();

package/dist/ui/components/Icon.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { getAppStore } from "rune-lab/state";
+  import { getAppStore } from "@internal/state";
   import { DEV } from "esm-env";
 
   /**

package/dist/ui/components/RuneProvider.svelte

@@ -12,15 +12,17 @@
         createShortcutStore,
         createCartStore,
         createSessionStore,
+        createExchangeRateStore,
         type CartStoreConfig,
-    } from "rune-lab/state";
-    import type { PersistenceDriver } from "rune-lab/core";
-    import { localStorageDriver } from "rune-lab/state";
-    import { RUNE_LAB_CONTEXT } from "rune-lab/state";
-    import type { AppData } from "rune-lab/state";
-    import type { Theme } from "rune-lab/state";
-    import type { Currency } from "rune-lab/state";
-    import { CommandPalette, ShortcutPalette, Toaster } from "rune-lab/ui";
+        type ExchangeRateStore,
+    } from "@internal/state";
+    import type { PersistenceDriver } from "@internal/core";
+    import { localStorageDriver } from "@internal/state";
+    import { RUNE_LAB_CONTEXT } from "@internal/state";
+    import type { AppData } from "@internal/state";
+    import type { Theme } from "@internal/state";
+    import type { Currency } from "@internal/state";
+    import { CommandPalette, ShortcutPalette, Toaster } from "../../mod";
 
     export interface RuneLabConfig {
         persistence?: PersistenceDriver;
@@ -46,6 +48,13 @@
         currencies?: Currency[];
         /** Default currency code when no persisted value exists */
         defaultCurrency?: string;
+        /** Bootstrap-time exchange rates */
+        exchangeRates?: {
+            base: string;
+            rates: Record<string, number>;
+        };
+        /** Callback when rates are initialized/updated */
+        onRatesUpdate?: (store: ExchangeRateStore) => void;
 
         // Cart (opt-in)
         /** CartStore configuration — when provided, a CartStore is created and registered in context */
@@ -80,9 +89,15 @@
     const initialDefaultTheme = untrack(() => config.defaultTheme);
     const initialCustomCurrencies = untrack(() => config.currencies);
     const initialDefaultCurrency = untrack(() => config.defaultCurrency);
+    const initialExchangeRates = untrack(() => config.exchangeRates);
     const initialCartConfig = untrack(() => config.cart);
     const initialAuthConfig = untrack(() => config.auth);
 
+    const exchangeRateStore = createExchangeRateStore();
+    if (initialExchangeRates) {
+        exchangeRateStore.setRates(initialExchangeRates.base, initialExchangeRates.rates);
+    }
+
     const themeStore = createThemeStore({
         driver: initialPersistence,
         customThemes: initialCustomThemes,
@@ -96,6 +111,7 @@
         driver: initialPersistence,
         customCurrencies: initialCustomCurrencies,
         defaultCurrency: initialDefaultCurrency,
+        exchangeRateStore,
     });
     const shortcutStore = createShortcutStore();
 
@@ -117,6 +133,7 @@
     setContext(RUNE_LAB_CONTEXT.theme, themeStore);
     setContext(RUNE_LAB_CONTEXT.language, languageStore);
     setContext(RUNE_LAB_CONTEXT.currency, currencyStore);
+    setContext(RUNE_LAB_CONTEXT.exchangeRate, exchangeRateStore);
     setContext(RUNE_LAB_CONTEXT.shortcut, shortcutStore);
     setContext(RUNE_LAB_CONTEXT.layout, layoutStore);
     setContext(RUNE_LAB_CONTEXT.commands, commandStore);
@@ -165,6 +182,9 @@
 
     onMount(() => {
         layoutStore.init();
+        if (config.onRatesUpdate) {
+            config.onRatesUpdate(exchangeRateStore);
+        }
     });
 
     // Meta tags derived from app store state

package/dist/ui/components/RuneProvider.svelte.d.ts

@@ -1,9 +1,9 @@
 import { type Snippet } from "svelte";
-import { type CartStoreConfig } from "rune-lab/state";
-import type { PersistenceDriver } from "rune-lab/core";
-import type { AppData } from "rune-lab/state";
-import type { Theme } from "rune-lab/state";
-import type { Currency } from "rune-lab/state";
+import { type CartStoreConfig, type ExchangeRateStore } from "@internal/state";
+import type { PersistenceDriver } from "@internal/core";
+import type { AppData } from "@internal/state";
+import type { Theme } from "@internal/state";
+import type { Currency } from "@internal/state";
 export interface RuneLabConfig {
     persistence?: PersistenceDriver;
     app?: Partial<AppData>;
@@ -24,6 +24,13 @@ export interface RuneLabConfig {
     currencies?: Currency[];
     /** Default currency code when no persisted value exists */
     defaultCurrency?: string;
+    /** Bootstrap-time exchange rates */
+    exchangeRates?: {
+        base: string;
+        rates: Record<string, number>;
+    };
+    /** Callback when rates are initialized/updated */
+    onRatesUpdate?: (store: ExchangeRateStore) => void;
     /** CartStore configuration — when provided, a CartStore is created and registered in context */
     cart?: CartStoreConfig<any>;
     /** When true, creates and registers a SessionStore in context */

package/dist/ui/components/Toaster.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { getToastStore } from "rune-lab/state";
+  import { getToastStore } from "@internal/state";
   import { portal } from "../actions/portal";
   import { flip } from "svelte/animate";
   import { fade, fly } from "svelte/transition";