rune-lab 0.4.0 → 0.4.1

package/dist/state/composables/useRuneLab.js

@@ -1,30 +0,0 @@
-// src/lib/composables/useRuneLab.ts
-import { getApiStore, getAppStore, getCommandStore, getCurrencyStore, getLanguageStore, getLayoutStore, getShortcutStore, getThemeStore, getToastStore, } from "../index.ts";
-import { getContext } from "svelte";
-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).
- */
-export function useRuneLab() {
-    // Session is optional — only present when auth is enabled
-    let session;
-    try {
-        session = getContext(RUNE_LAB_CONTEXT.session);
-    }
-    catch {
-        // Auth not enabled — session stays undefined
-    }
-    return {
-        app: getAppStore(),
-        api: getApiStore(),
-        toast: getToastStore(),
-        theme: getThemeStore(),
-        language: getLanguageStore(),
-        currency: getCurrencyStore(),
-        shortcut: getShortcutStore(),
-        layout: getLayoutStore(),
-        commands: getCommandStore(),
-        session,
-    };
-}

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

@@ -1,33 +0,0 @@
-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

@@ -1,75 +0,0 @@
-// 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

@@ -1,15 +0,0 @@
-export declare const RUNE_LAB_CONTEXT: {
-    readonly app: symbol;
-    readonly api: symbol;
-    readonly toast: symbol;
-    readonly theme: symbol;
-    readonly language: symbol;
-    readonly currency: symbol;
-    readonly shortcut: symbol;
-    readonly layout: symbol;
-    readonly commands: symbol;
-    readonly persistence: symbol;
-    readonly cart: symbol;
-    readonly session: symbol;
-    readonly exchangeRate: symbol;
-};

package/dist/state/context.js

@@ -1,16 +0,0 @@
-// src/lib/context.ts
-export const RUNE_LAB_CONTEXT = {
-    app: Symbol("rl:app"),
-    api: Symbol("rl:api"),
-    toast: Symbol("rl:toast"),
-    theme: Symbol("rl:theme"),
-    language: Symbol("rl:language"),
-    currency: Symbol("rl:currency"),
-    shortcut: Symbol("rl:shortcut"),
-    layout: Symbol("rl:layout"),
-    commands: Symbol("rl:commands"),
-    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,28 +0,0 @@
-import { type PersistenceDriver } from "@internal/core";
-export type ConfigStore<T extends object> = {
-    current: T[keyof T];
-    available: T[];
-    set: (id: T[keyof T]) => void;
-    get: (id: T[keyof T]) => T | undefined;
-    getProp: <K extends keyof T>(prop: K, id?: T[keyof T]) => T[K] | undefined;
-    /** Append additional items (e.g. custom themes/currencies from the consuming app) */
-    addItems: (newItems: T[]) => void;
-};
-export interface ConfigStoreOptions<T extends object> {
-    /** Array of available items */
-    items: readonly T[];
-    /** Storage key used by the persistence driver */
-    storageKey: string;
-    /** Display name for logging (e.g., "Theme", "Language") */
-    displayName: string;
-    /** Key to use as identifier (e.g., "code", "name") */
-    idKey: keyof T;
-    /** Icon for logs */
-    icon?: string;
-    /** Persistence driver */
-    driver?: PersistenceDriver;
-}
-/**
- * Creates a reactive configuration store with persistence
- */
-export declare function createConfigStore<T extends object>(options: ConfigStoreOptions<T>): ConfigStore<T>;

package/dist/state/createConfigStore.svelte.js

@@ -1,72 +0,0 @@
-import { createInMemoryDriver } from "./persistence/drivers.ts";
-import { DEV } from "esm-env";
-/**
- * Internal class implementation for configuration stores.
- * Stable class definition avoids potential issues with multiple definitions in SSR.
- */
-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;
-        }
-        if (DEV) {
-            console.log(`${options.icon ?? "⚙️"} ${options.displayName} configured:`, {
-                current: this.current,
-            });
-        }
-    }
-    /**
-     * Set current item with validation
-     */
-    set(id) {
-        const item = this.get(id);
-        if (!item) {
-            console.warn(`${this.#options.displayName} "${id}" not found`);
-            return;
-        }
-        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);
-            }
-        }
-    }
-}
-/**
- * Creates a reactive configuration store with persistence
- */
-export function createConfigStore(options) {
-    return new ConfigStoreImpl(options);
-}

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

@@ -1,32 +0,0 @@
-import { type ConfigStore, createConfigStore } from "./createConfigStore.svelte.ts";
-/**
- * Currency configuration
- * Based on ISO 4217 currency codes
- */
-export interface Currency {
-    code: string;
-    symbol: string;
-    decimals: number;
-}
-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): 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(): 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,96 +0,0 @@
-import { createConfigStore, } from "./createConfigStore.svelte.ts";
-import { getContext } from "svelte";
-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.
- */
-function buildDineroDef(meta) {
-    return {
-        code: meta.code,
-        base: 10,
-        exponent: meta.decimals,
-    };
-}
-const CURRENCIES = [
-    { code: "USD", symbol: "$", decimals: 2 },
-    { code: "EUR", symbol: "€", decimals: 2 },
-    { code: "GBP", symbol: "£", decimals: 2 },
-    { code: "MXN", symbol: "$", decimals: 2 },
-    { code: "CAD", symbol: "C$", decimals: 2 },
-    { code: "BRL", symbol: "R$", decimals: 2 },
-    { code: "INR", symbol: "₹", decimals: 2 },
-    { code: "CNY", symbol: "¥", decimals: 2 },
-    { code: "JPY", symbol: "¥", decimals: 0 },
-    { 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" &&
-        "driver" in driverOrOptions
-        ? driverOrOptions
-        : {
-            driver: driverOrOptions,
-        };
-    const resolvedDriver = resolveDriver(opts.driver);
-    const store = createConfigStore({
-        items: CURRENCIES,
-        storageKey: "currency",
-        displayName: "Currency",
-        idKey: "code",
-        icon: "💰",
-        driver: resolvedDriver,
-    });
-    const exchangeRateStore = opts.exchangeRateStore;
-    /**
-     * Extension: Atomic currency registration.
-     * Updates both the Dinero registry (core) and the reactive store (UI).
-     *
-     * @remarks Custom currencies with non-decimal base systems must use
-     * registerCurrency() from @internal/core explicitly before addItems().
-     */
-    function addCurrency(meta, dineroDef) {
-        const def = dineroDef || buildDineroDef(meta);
-        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) {
-            registerCurrency(c.code, buildDineroDef(c));
-        }
-        store.addItems(opts.customCurrencies);
-    }
-    // Set default currency if provided and no persisted value found
-    if (!resolvedDriver?.get("currency") && opts.defaultCurrency) {
-        if (store.get(opts.defaultCurrency)) {
-            store.set(opts.defaultCurrency);
-        }
-    }
-    // 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

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

package/dist/state/currency.test.js

@@ -1,35 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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;

package/dist/state/exchange-rate.svelte.js

@@ -1,145 +0,0 @@
-// sdk/state/src/exchange-rate.svelte.ts
-import { getContext } from "svelte";
-import { convertAmount, convertMoney, createMoney, CURRENCY_MAP, 
-// Phase 2: ConversionStrategies from sdk/core
-resolveRate, scaledRate, toMoneySnapshot, } from "@internal/core";
-import { RUNE_LAB_CONTEXT } from "./context.ts";
-export class ExchangeRateStore {
-    #rates = $state({});
-    #baseCurrency = $state("USD");
-    /**
-     * The current exchange rates relative to the base currency.
-     */
-    get rates() {
-        return this.#rates;
-    }
-    /**
-     * The base currency all rates are relative to.
-     */
-    get baseCurrency() {
-        return this.#baseCurrency;
-    }
-    /**
-     * Returns true if exchange rates have been loaded.
-     */
-    get hasRates() {
-        return Object.keys(this.#rates).length > 0;
-    }
-    /**
-     * 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, rawRates) {
-        const nextRates = {};
-        for (const [code, rate] of Object.entries(rawRates)) {
-            nextRates[code] = scaledRate(rate, 4);
-        }
-        this.#baseCurrency = base;
-        this.#rates = nextRates;
-    }
-    /**
-     * Directly set pre-scaled rates.
-     */
-    setScaledRates(base, rates) {
-        this.#baseCurrency = base;
-        this.#rates = rates;
-    }
-    /**
-     * Resolves the exchange rate between two currencies.
-     * Returns a ScaledRate representing how many units of toCode are in 1 unit of fromCode.
-     */
-    getRate(fromCode, toCode) {
-        if (fromCode === toCode)
-            return 1;
-        const fromCurrency = CURRENCY_MAP[fromCode];
-        const toCurrency = CURRENCY_MAP[toCode];
-        if (!fromCurrency || !toCurrency)
-            return undefined;
-        if (!this.hasRates)
-            return undefined;
-        try {
-            // 1 unit of fromCode (major unit)
-            const oneUnit = Math.pow(Array.isArray(fromCurrency.base)
-                ? fromCurrency.base[0]
-                : fromCurrency.base, fromCurrency.exponent);
-            const currentRates = this.#rates;
-            const currentBase = this.#baseCurrency;
-            const sourceMoney = createMoney(oneUnit, fromCode);
-            let targetMoney;
-            if (fromCode === currentBase) {
-                // Direct: base → target
-                targetMoney = convertMoney(sourceMoney, toCode, currentRates);
-            }
-            else if (toCode === currentBase) {
-                // Inverse: target → base
-                const rateToBase = currentRates[fromCode];
-                if (!rateToBase)
-                    return undefined;
-                const r = resolveRate(rateToBase);
-                targetMoney = convertMoney(sourceMoney, toCode, {
-                    [toCode]: scaledRate(1 / r, 6),
-                });
-            }
-            else {
-                // Triangular: source → base → target
-                const rateToBase = currentRates[fromCode];
-                const rateToTarget = currentRates[toCode];
-                if (!rateToBase || !rateToTarget)
-                    return undefined;
-                const r1 = resolveRate(rateToBase);
-                const r2 = resolveRate(rateToTarget);
-                targetMoney = convertMoney(sourceMoney, toCode, {
-                    [toCode]: scaledRate(r2 / r1, 6),
-                });
-            }
-            const snapshot = toMoneySnapshot(targetMoney);
-            return {
-                amount: snapshot.amount,
-                scale: snapshot.scale,
-            };
-        }
-        catch (_err) {
-            return undefined;
-        }
-    }
-    /**
-     * Internal conversion logic that handles triangulation through base currency.
-     */
-    convertAmount(amount, fromCode, toCode) {
-        if (fromCode === toCode)
-            return amount;
-        if (!this.hasRates)
-            return amount;
-        // Direct: Base → Target
-        if (fromCode === this.#baseCurrency) {
-            return convertAmount(amount, fromCode, toCode, this.#rates);
-        }
-        // Inverse: Target → Base
-        if (toCode === this.#baseCurrency) {
-            const rateToBase = this.#rates[fromCode];
-            if (!rateToBase)
-                return amount;
-            const r = resolveRate(rateToBase);
-            const inverseRate = scaledRate(1 / r, 6);
-            return convertAmount(amount, fromCode, toCode, {
-                [toCode]: inverseRate,
-            });
-        }
-        // Triangulation: From → Base → To
-        const amountInBase = this.convertAmount(amount, fromCode, this.#baseCurrency);
-        return this.convertAmount(amountInBase, this.#baseCurrency, toCode);
-    }
-}
-/**
- * Factory to create the ExchangeRateStore.
- */
-export function createExchangeRateStore() {
-    return new ExchangeRateStore();
-}
-/**
- * Consumer to retrieve the ExchangeRateStore from context.
- */
-export function getExchangeRateStore() {
-    return getContext(RUNE_LAB_CONTEXT.exchangeRate);
-}

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

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