rune-lab 0.3.0 → 0.4.0

package/dist/state/composables/useMoneyFilter.js

@@ -0,0 +1,81 @@
+// sdk/state/src/composables/useMoneyFilter.ts
+import { getContext } from "svelte";
+import { RUNE_LAB_CONTEXT } from "../context.ts";
+import { useMoney } from "./useMoney.ts";
+/**
+ * A reactive currency-aware filter composable.
+ * Handles min/max thresholds that auto-convert when the display currency changes.
+ */
+export function useMoneyFilter(options = {}) {
+    const currencyStore = getContext(RUNE_LAB_CONTEXT.currency);
+    const { format } = useMoney();
+    let min = $state(options.min ?? 0);
+    let max = $state(options.max ?? Infinity);
+    const unit = options.unit ?? "minor";
+    const autoConvertOnChange = options.autoConvertOnChange ?? true;
+    let lastCurrency = String(currencyStore.current);
+    $effect(() => {
+        const currentCurrency = String(currencyStore.current);
+        if (autoConvertOnChange && currentCurrency !== lastCurrency) {
+            if (currencyStore.canConvert) {
+                if (min !== 0) {
+                    min = currencyStore.convertAmount(min, lastCurrency, currentCurrency);
+                }
+                if (max !== Infinity) {
+                    max = currencyStore.convertAmount(max, lastCurrency, currentCurrency);
+                }
+            }
+            else {
+                // Reset if no rates available
+                min = 0;
+                max = Infinity;
+            }
+        }
+        lastCurrency = currentCurrency;
+    });
+    function setMin(value) {
+        min = value;
+    }
+    function setMax(value) {
+        max = value;
+    }
+    function reset() {
+        min = 0;
+        max = Infinity;
+    }
+    /**
+     * Checks if an amount (in its entity currency) matches the current filter.
+     */
+    function matches(amount, entityCurrency) {
+        const currentCurrency = String(currencyStore.current);
+        // Convert entity amount to display currency for comparison
+        const convertedAmount = currencyStore.convertAmount(amount, entityCurrency, currentCurrency);
+        return convertedAmount >= min && convertedAmount <= max;
+    }
+    const displayMin = $derived(format(min, undefined, unit));
+    const displayMax = $derived(max === Infinity ? "∞" : format(max, undefined, unit));
+    return {
+        get min() {
+            return min;
+        },
+        set min(v) {
+            min = v;
+        },
+        get max() {
+            return max;
+        },
+        set max(v) {
+            max = v;
+        },
+        get displayMin() {
+            return displayMin;
+        },
+        get displayMax() {
+            return displayMax;
+        },
+        setMin,
+        setMax,
+        reset,
+        matches,
+    };
+}

package/dist/state/composables/usePersistence.d.ts

@@ -1,2 +1,2 @@
-import type { PersistenceDriver } from "rune-lab/core";
+import type { PersistenceDriver } from "@internal/core";
 export declare function usePersistence(): PersistenceDriver | undefined;

package/dist/state/composables/usePersistence.js

@@ -1,5 +1,5 @@
 import { getContext } from "svelte";
-import { RUNE_LAB_CONTEXT } from "../context";
+import { RUNE_LAB_CONTEXT } from "../context.ts";
 export function usePersistence() {
     return getContext(RUNE_LAB_CONTEXT.persistence);
 }

package/dist/state/composables/useRuneLab.d.ts

@@ -1,4 +1,4 @@
-import { getApiStore, getAppStore, getCommandStore, getCurrencyStore, getLanguageStore, getLayoutStore, getShortcutStore, getThemeStore, getToastStore, type SessionStore } from "../index";
+import { getApiStore, getAppStore, getCommandStore, getCurrencyStore, getLanguageStore, getLayoutStore, getShortcutStore, getThemeStore, getToastStore, type SessionStore } from "../index.ts";
 export interface RuneLabContext {
     app: ReturnType<typeof getAppStore>;
     api: ReturnType<typeof getApiStore>;

package/dist/state/composables/useRuneLab.js

@@ -1,7 +1,7 @@
 // src/lib/composables/useRuneLab.ts
-import { getApiStore, getAppStore, getCommandStore, getCurrencyStore, getLanguageStore, getLayoutStore, getShortcutStore, getThemeStore, getToastStore, } from "../index";
+import { getApiStore, getAppStore, getCommandStore, getCurrencyStore, getLanguageStore, getLayoutStore, getShortcutStore, getThemeStore, getToastStore, } from "../index.ts";
 import { getContext } from "svelte";
-import { RUNE_LAB_CONTEXT } from "../context";
+import { RUNE_LAB_CONTEXT } from "../context.ts";
 /**
  * Retrieves all Rune Lab stores from the Svelte context tree.
  * Must be called during component initialization (in the `<script>` block).

package/dist/state/composables/useShortcuts.d.ts

@@ -0,0 +1,33 @@
+import type { ShortcutConfig } from "@internal/core";
+/**
+ * Declarative shortcut registration composable.
+ * Registers all shortcuts via ShortcutStore in a single `$effect` and
+ * automatically unregisters them when the component is destroyed.
+ *
+ * Must be called at component initialization time (top-level in `<script>`),
+ * not inside event handlers.
+ *
+ * @param configs - Array of ShortcutConfig from sdk/core
+ * @returns Object with `registered` getter for the list of registered IDs
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useShortcuts } from 'rune-lab/state';
+ *
+ *   useShortcuts([
+ *     {
+ *       id: "save:document",
+ *       keys: "ctrl+s",
+ *       handler: (e) => { e.preventDefault(); save(); },
+ *       label: "Save document",
+ *       category: "Editing",
+ *     },
+ *   ]);
+ * </script>
+ * ```
+ */
+export declare function useShortcuts(configs: ShortcutConfig[]): {
+    /** IDs of all shortcuts registered by this composable */
+    readonly registered: string[];
+};

package/dist/state/composables/useShortcuts.js

@@ -0,0 +1,75 @@
+// sdk/state/src/composables/useShortcuts.ts
+// Declarative shortcut registration with automatic lifecycle cleanup.
+// Bridges ShortcutConfig (sdk/core) → ShortcutStore (sdk/state).
+import { getShortcutStore } from "../shortcuts.svelte.ts";
+/**
+ * Declarative shortcut registration composable.
+ * Registers all shortcuts via ShortcutStore in a single `$effect` and
+ * automatically unregisters them when the component is destroyed.
+ *
+ * Must be called at component initialization time (top-level in `<script>`),
+ * not inside event handlers.
+ *
+ * @param configs - Array of ShortcutConfig from sdk/core
+ * @returns Object with `registered` getter for the list of registered IDs
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useShortcuts } from 'rune-lab/state';
+ *
+ *   useShortcuts([
+ *     {
+ *       id: "save:document",
+ *       keys: "ctrl+s",
+ *       handler: (e) => { e.preventDefault(); save(); },
+ *       label: "Save document",
+ *       category: "Editing",
+ *     },
+ *   ]);
+ * </script>
+ * ```
+ */
+export function useShortcuts(configs) {
+    const shortcutStore = getShortcutStore();
+    // Convert ShortcutConfig[] to ShortcutEntry[] respecting the `when` predicate
+    function toEntries(configs) {
+        return configs.map((config) => ({
+            id: config.id,
+            keys: config.keys,
+            handler: (event) => {
+                // Check `when` predicate before firing
+                if (config.when && !config.when())
+                    return;
+                config.handler(event);
+            },
+            label: config.label ?? config.id,
+            category: config.category ?? "General",
+            scope: config.scope ?? "global",
+            enabled: true,
+            hidden: !config.label, // Hide from palette if no label
+        }));
+    }
+    // Register all shortcuts
+    const entries = toEntries(configs);
+    const ids = entries.map((e) => e.id);
+    for (const entry of entries) {
+        shortcutStore.register(entry);
+    }
+    // Auto-cleanup using $effect.root for lifecycle management
+    $effect(() => {
+        // This effect runs on mount — shortcuts are already registered above.
+        // Return cleanup that unregisters all shortcuts on destroy.
+        return () => {
+            for (const id of ids) {
+                shortcutStore.unregister(id);
+            }
+        };
+    });
+    return {
+        /** IDs of all shortcuts registered by this composable */
+        get registered() {
+            return ids;
+        },
+    };
+}

package/dist/state/context.d.ts

@@ -11,4 +11,5 @@ export declare const RUNE_LAB_CONTEXT: {
     readonly persistence: symbol;
     readonly cart: symbol;
     readonly session: symbol;
+    readonly exchangeRate: symbol;
 };

package/dist/state/context.js

@@ -12,4 +12,5 @@ export const RUNE_LAB_CONTEXT = {
     persistence: Symbol("rl:persistence"),
     cart: Symbol("rl:cart"),
     session: Symbol("rl:session"),
+    exchangeRate: Symbol("rl:exchange-rate"),
 };

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

@@ -1,5 +1,5 @@
-import { type PersistenceDriver } from "rune-lab/core";
-export type ConfigStore<T extends ConfigItem> = {
+import { type PersistenceDriver } from "@internal/core";
+export type ConfigStore<T extends object> = {
     current: T[keyof T];
     available: T[];
     set: (id: T[keyof T]) => void;
@@ -8,15 +8,7 @@ export type ConfigStore<T extends ConfigItem> = {
     /** Append additional items (e.g. custom themes/currencies from the consuming app) */
     addItems: (newItems: T[]) => void;
 };
-/**
- * Generic configuration store factory
- * Creates type-safe stores for theme, language, currency, etc.
- * with validation, persistence, and utilities
- */
-export interface ConfigItem {
-    [key: string]: any;
-}
-export interface ConfigStoreOptions<T extends ConfigItem> {
+export interface ConfigStoreOptions<T extends object> {
     /** Array of available items */
     items: readonly T[];
     /** Storage key used by the persistence driver */
@@ -33,23 +25,4 @@ export interface ConfigStoreOptions<T extends ConfigItem> {
 /**
  * Creates a reactive configuration store with persistence
  */
-export declare function createConfigStore<T extends ConfigItem>(options: ConfigStoreOptions<T>): {
-    current: T[keyof T];
-    available: T[];
-    /**
-     * Set current item with validation
-     */
-    set(id: T[keyof T]): void;
-    /**
-     * Get item by id
-     */
-    get(id: T[keyof T]): T | undefined;
-    /**
-     * Get property from current or specified item
-     */
-    getProp<K extends keyof T>(prop: K, id?: T[keyof T]): T[K] | undefined;
-    /**
-     * Append additional items (deduplicates by idKey)
-     */
-    addItems(newItems: T[]): void;
-};
+export declare function createConfigStore<T extends object>(options: ConfigStoreOptions<T>): ConfigStore<T>;

package/dist/state/createConfigStore.svelte.js

@@ -1,61 +1,72 @@
-// client/sdk/devtools/src/patterns/createConfigStore.svelte.ts
-import { createInMemoryDriver } from "./persistence/drivers";
+import { createInMemoryDriver } from "./persistence/drivers.ts";
 import { DEV } from "esm-env";
 /**
- * Creates a reactive configuration store with persistence
+ * Internal class implementation for configuration stores.
+ * Stable class definition avoids potential issues with multiple definitions in SSR.
  */
-export function createConfigStore(options) {
-    const { items, storageKey, displayName, idKey, icon = "⚙️", driver = createInMemoryDriver(), } = options;
-    class ConfigStore {
-        current = $state(items[0]?.[idKey] ?? "");
-        available = $state([...items]);
-        constructor() {
-            const saved = driver.get(storageKey);
-            // Only load saved if it actually exists in our available items
-            if (saved && this.get(saved)) {
-                this.current = saved;
-            }
-            if (DEV) {
-                console.log(`${icon} ${displayName} configured:`, {
-                    current: this.current,
-                });
-            }
+class ConfigStoreImpl {
+    current = $state(null);
+    available = $state([]);
+    #options;
+    #driver;
+    constructor(options) {
+        this.#options = options;
+        const { items, idKey, storageKey, driver = createInMemoryDriver() } = options;
+        this.#driver = driver;
+        this.available = [...items];
+        this.current = items[0]?.[idKey] ?? "";
+        const saved = this.#driver.get(storageKey);
+        // Only load saved if it actually exists in our available items
+        if (saved && this.get(saved)) {
+            this.current = saved;
         }
-        /**
-         * Set current item with validation
-         */
-        set(id) {
-            const item = this.get(id);
-            if (!item) {
-                console.warn(`${displayName} "${id}" not found`);
-                return;
-            }
-            this.current = id;
-            driver.set(storageKey, String(id));
-        }
-        /**
-         * Get item by id
-         */
-        get(id) {
-            return this.available.find((item) => item[idKey] === id);
+        if (DEV) {
+            console.log(`${options.icon ?? "⚙️"} ${options.displayName} configured:`, {
+                current: this.current,
+            });
         }
-        /**
-         * Get property from current or specified item
-         */
-        getProp(prop, id) {
-            const targetId = id ?? this.current;
-            return this.get(targetId)?.[prop];
+    }
+    /**
+     * Set current item with validation
+     */
+    set(id) {
+        const item = this.get(id);
+        if (!item) {
+            console.warn(`${this.#options.displayName} "${id}" not found`);
+            return;
         }
-        /**
-         * Append additional items (deduplicates by idKey)
-         */
-        addItems(newItems) {
-            for (const item of newItems) {
-                if (!this.get(item[idKey])) {
-                    this.available.push(item);
-                }
+        this.current = id;
+        this.#driver.set(this.#options.storageKey, String(id));
+    }
+    /**
+     * Get item by id
+     */
+    get(id) {
+        const idKey = this.#options.idKey;
+        return this.available.find((item) => item[idKey] === id);
+    }
+    /**
+     * Get property from current or specified item
+     */
+    getProp(prop, id) {
+        const targetId = id ?? this.current;
+        return this.get(targetId)?.[prop];
+    }
+    /**
+     * Append additional items (deduplicates by idKey)
+     */
+    addItems(newItems) {
+        const idKey = this.#options.idKey;
+        for (const item of newItems) {
+            if (!this.get(item[idKey])) {
+                this.available.push(item);
             }
         }
     }
-    return new ConfigStore();
+}
+/**
+ * Creates a reactive configuration store with persistence
+ */
+export function createConfigStore(options) {
+    return new ConfigStoreImpl(options);
 }

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

@@ -1,3 +1,4 @@
+import { type ConfigStore, createConfigStore } from "./createConfigStore.svelte.ts";
 /**
  * Currency configuration
  * Based on ISO 4217 currency codes
@@ -7,22 +8,25 @@ export interface Currency {
     symbol: string;
     decimals: number;
 }
-import type { PersistenceDriver } from "rune-lab/core";
+import type { PersistenceDriver } from "@internal/core";
+import { type ExchangeRateStore } from "./exchange-rate.svelte.ts";
 export interface CurrencyStoreOptions {
     driver?: PersistenceDriver | (() => PersistenceDriver | undefined);
     /** Additional custom currencies to append to the built-in set */
     customCurrencies?: Currency[];
     /** Default currency code if no persisted value exists */
     defaultCurrency?: string;
+    /** Wired exchange rate store for conversions */
+    exchangeRateStore?: ExchangeRateStore;
 }
-export declare function createCurrencyStore(driverOrOptions?: PersistenceDriver | (() => PersistenceDriver | undefined) | CurrencyStoreOptions): {
-    addCurrency: (meta: Currency, dineroDef?: any) => void;
-    current: string | number;
-    available: Currency[];
+export declare function createCurrencyStore(driverOrOptions?: PersistenceDriver | (() => PersistenceDriver | undefined) | CurrencyStoreOptions): ReturnType<typeof createConfigStore<Currency>> & {
+    addCurrency: (meta: Currency, dineroDef?: unknown) => void;
+    convertAmount: (amount: number, fromCode: string, toCode?: string) => number;
+    readonly canConvert: boolean;
 };
 export type CurrencyStore = ReturnType<typeof createCurrencyStore>;
-export declare function getCurrencyStore(): {
-    addCurrency: (meta: Currency, dineroDef?: any) => void;
-    current: string | number;
-    available: Currency[];
+export declare function getCurrencyStore(): ConfigStore<Currency> & {
+    addCurrency: (meta: Currency, dineroDef?: unknown) => void;
+    convertAmount: (amount: number, fromCode: string, toCode?: string) => number;
+    readonly canConvert: boolean;
 };

package/dist/state/currency.svelte.js

@@ -1,7 +1,7 @@
-import { createConfigStore, } from "./createConfigStore.svelte";
+import { createConfigStore, } from "./createConfigStore.svelte.ts";
 import { getContext } from "svelte";
-import { RUNE_LAB_CONTEXT } from "./context";
-import { registerCurrency } from "rune-lab/core";
+import { RUNE_LAB_CONTEXT } from "./context.ts";
+import { registerCurrency } from "@internal/core";
 /**
  * Helper to build a minimal Dinero definition from Currency metadata.
  * Assumes base 10 (standard decimal) for auto-registration.
@@ -26,6 +26,7 @@ const CURRENCIES = [
     { code: "KRW", symbol: "₩", decimals: 0 },
     { code: "AED", symbol: "د.إ", decimals: 2 },
 ];
+import { resolveDriver } from "./persistence/provider.ts";
 export function createCurrencyStore(driverOrOptions) {
     // Normalize overloaded argument
     const opts = driverOrOptions && typeof driverOrOptions === "object" &&
@@ -34,9 +35,7 @@ export function createCurrencyStore(driverOrOptions) {
         : {
             driver: driverOrOptions,
         };
-    const resolvedDriver = typeof opts.driver === "function"
-        ? opts.driver()
-        : opts.driver;
+    const resolvedDriver = resolveDriver(opts.driver);
     const store = createConfigStore({
         items: CURRENCIES,
         storageKey: "currency",
@@ -45,6 +44,7 @@ export function createCurrencyStore(driverOrOptions) {
         icon: "💰",
         driver: resolvedDriver,
     });
+    const exchangeRateStore = opts.exchangeRateStore;
     /**
      * Extension: Atomic currency registration.
      * Updates both the Dinero registry (core) and the reactive store (UI).
@@ -57,6 +57,18 @@ export function createCurrencyStore(driverOrOptions) {
         registerCurrency(meta.code, def);
         store.addItems([meta]);
     }
+    /**
+     * Converts an amount from one currency to another.
+     * Defaults to converting to the current store currency.
+     */
+    function convertAmount(amount, fromCode, toCode) {
+        const target = toCode ?? String(store.current);
+        if (fromCode === target)
+            return amount;
+        if (!exchangeRateStore || !exchangeRateStore.hasRates)
+            return amount;
+        return exchangeRateStore.convertAmount(amount, fromCode, target);
+    }
     // Append and auto-register custom currencies if provided
     if (opts.customCurrencies?.length) {
         for (const c of opts.customCurrencies) {
@@ -70,10 +82,14 @@ export function createCurrencyStore(driverOrOptions) {
             store.set(opts.defaultCurrency);
         }
     }
-    return {
-        ...store,
-        addCurrency,
-    };
+    // Explicitly attach method to ensure prototype is preserved and method is available
+    // across different build environments.
+    Object.defineProperties(store, {
+        addCurrency: { value: addCurrency },
+        convertAmount: { value: convertAmount },
+        canConvert: { get: () => !!exchangeRateStore?.hasRates },
+    });
+    return store;
 }
 export function getCurrencyStore() {
     return getContext(RUNE_LAB_CONTEXT.currency);

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

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

package/dist/state/currency.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { createCurrencyStore } from "./currency.svelte.ts";
+describe("Currency Store", () => {
+    it("should have prototype methods from ConfigStore", () => {
+        const store = createCurrencyStore();
+        // These come from the ConfigStore class prototype
+        expect(typeof store.get).toBe("function");
+        expect(typeof store.set).toBe("function");
+        expect(typeof store.getProp).toBe("function");
+        expect(typeof store.addItems).toBe("function");
+        // These are instance properties
+        expect(store.current).toBeDefined();
+        expect(Array.isArray(store.available)).toBe(true);
+        // This is the extension method
+        expect(typeof store.addCurrency).toBe("function");
+    });
+    it("should correctly use prototype methods", () => {
+        const store = createCurrencyStore();
+        const usd = store.get("USD");
+        expect(usd).toBeDefined();
+        expect(usd?.code).toBe("USD");
+        expect(usd?.symbol).toBe("$");
+    });
+    it("should add a new currency and keep methods", () => {
+        const store = createCurrencyStore();
+        store.addCurrency({ code: "BTC", symbol: "₿", decimals: 8 });
+        const btc = store.get("BTC");
+        expect(btc).toBeDefined();
+        expect(btc?.code).toBe("BTC");
+        expect(btc?.decimals).toBe(8);
+        // Methods still exist after interaction
+        expect(typeof store.get).toBe("function");
+        expect(typeof store.set).toBe("function");
+    });
+});

package/dist/state/exchange-rate.svelte.d.ts

@@ -0,0 +1,43 @@
+import { type RateMap, type ScaledRate } from "@internal/core";
+export declare class ExchangeRateStore {
+    #private;
+    /**
+     * The current exchange rates relative to the base currency.
+     */
+    get rates(): RateMap;
+    /**
+     * The base currency all rates are relative to.
+     */
+    get baseCurrency(): string;
+    /**
+     * Returns true if exchange rates have been loaded.
+     */
+    get hasRates(): boolean;
+    /**
+     * Set exchange rates from a human-readable float map.
+     * @param base - The base currency code (e.g., "USD")
+     * @param rawRates - A map of currency codes to float rates (e.g., { MXN: 17.23 })
+     */
+    setRates(base: string, rawRates: Record<string, number>): void;
+    /**
+     * Directly set pre-scaled rates.
+     */
+    setScaledRates(base: string, rates: RateMap): void;
+    /**
+     * Resolves the exchange rate between two currencies.
+     * Returns a ScaledRate representing how many units of toCode are in 1 unit of fromCode.
+     */
+    getRate(fromCode: string, toCode: string): ScaledRate | number | undefined;
+    /**
+     * Internal conversion logic that handles triangulation through base currency.
+     */
+    convertAmount(amount: number, fromCode: string, toCode: string): number;
+}
+/**
+ * Factory to create the ExchangeRateStore.
+ */
+export declare function createExchangeRateStore(): ExchangeRateStore;
+/**
+ * Consumer to retrieve the ExchangeRateStore from context.
+ */
+export declare function getExchangeRateStore(): ExchangeRateStore;