rune-lab 0.3.1 → 0.4.1

package/src/runes/plugins/money/src/MoneyDisplay.svelte

@@ -0,0 +1,142 @@
+<script lang="ts">
+    import { getLanguageStore, getCurrencyStore } from "@rune-lab/kernel";
+    import {
+        formatAmount,
+        toMinorUnit,
+        type ISO4217Code,
+        MoneyPrimitive,
+    } from "@rune-lab/money";
+    import { DEV } from "esm-env";
+
+    let {
+        amount: amountProp,
+        money,
+        unit = "minor",
+        fallback = "—",
+        currency,
+        sourceCurrency,
+        showSourceCurrency = false,
+        noRatesFallback,
+        locale,
+        compact = false,
+    } = $props<{
+        /** Amount in minor or major units (see unit prop) */
+        amount?: number | null | undefined;
+        /**
+         * MoneyPrimitive instance. When provided, amount, currency, and unit
+         * are derived from the primitive. Takes precedence over raw amount.
+         */
+        money?: MoneyPrimitive;
+        /**
+         * Whether the amount is in 'major' (e.g., pesos) or 'minor' (e.g., centavos) units.
+         * @deprecated Use `money` prop with MoneyPrimitive instead.
+         * Defaults to 'minor' for backward compatibility.
+         */
+        unit?: "major" | "minor";
+        /** String to display if amount is null, undefined, or NaN. Defaults to "—" */
+        fallback?: string;
+        /** Override currency code (defaults to CurrencyStore.current) */
+        currency?: ISO4217Code | string;
+        /** The currency the amount is stored in (e.g. MXN) */
+        sourceCurrency?: ISO4217Code | string;
+        /** Show the original currency as a label */
+        showSourceCurrency?: boolean;
+        /** Fallback text if conversion is needed but rates are missing */
+        noRatesFallback?: string;
+        /** Override locale (defaults to LanguageStore.current) */
+        locale?: string;
+        /** Use compact notation (e.g., $1.2M) */
+        compact?: boolean;
+    }>();
+
+    // Dev warning for deprecated usage
+    $effect(() => {
+        if (DEV && money && unit !== "minor") {
+            console.warn(
+                "[MoneyDisplay] The `unit` prop is deprecated when using `money: MoneyPrimitive`. " +
+                    "The unit is derived from the MoneyPrimitive instance.",
+            );
+        }
+    });
+
+    // Derive effective values from MoneyPrimitive or legacy props
+    const amount = $derived(money ? money.minor : amountProp);
+    const effectiveSourceCurrency = $derived(
+        money ? money.currencyCode : sourceCurrency,
+    );
+
+    const currencyStore = getCurrencyStore();
+    const languageStore = getLanguageStore();
+
+    const resolvedDisplayCurrency = $derived(
+        currency ?? String(currencyStore.current),
+    );
+
+    const resolvedSourceCurrency = $derived(
+        effectiveSourceCurrency ?? resolvedDisplayCurrency,
+    );
+
+    const resolvedLocale = $derived(
+        locale ?? (String(languageStore.current) || "en"),
+    );
+
+    const currencyMeta = $derived(currencyStore.get(resolvedDisplayCurrency));
+    const decimals = $derived(currencyMeta?.decimals ?? 2);
+
+    const formatted = $derived.by(() => {
+        // If amount is null/undefined/NaN, use fallback
+        if (
+            amount === null ||
+            amount === undefined ||
+            (typeof amount === "number" && isNaN(amount))
+        ) {
+            return fallback;
+        }
+
+        // Convert to minor units if necessary (in source currency)
+        const minorAmount =
+            unit === "major"
+                ? toMinorUnit(Number(amount), resolvedSourceCurrency)
+                : amount;
+
+        // Conversion logic
+        let displayAmount = Number(minorAmount);
+        let displayCurrency = resolvedDisplayCurrency;
+
+        if (resolvedSourceCurrency !== resolvedDisplayCurrency) {
+            if (currencyStore.canConvert) {
+                displayAmount = currencyStore.convertAmount(
+                    Number(minorAmount),
+                    resolvedSourceCurrency,
+                    resolvedDisplayCurrency,
+                );
+            } else if (noRatesFallback) {
+                return noRatesFallback;
+            } else {
+                // Fallback to source currency display if rates missing
+                displayCurrency = resolvedSourceCurrency;
+            }
+        }
+
+        if (compact) {
+            const displayDecimals =
+                currencyStore.get(displayCurrency)?.decimals ?? 2;
+            const majorUnits = displayAmount / Math.pow(10, displayDecimals);
+            return new Intl.NumberFormat(resolvedLocale, {
+                style: "currency",
+                currency: displayCurrency,
+                notation: "compact",
+                maximumFractionDigits: 1,
+            }).format(majorUnits);
+        }
+
+        return formatAmount(displayAmount, displayCurrency, resolvedLocale);
+    });
+</script>
+
+<data value={amount} class="rl-money-display tabular-nums">
+    {formatted}
+    {#if showSourceCurrency && sourceCurrency && sourceCurrency !== resolvedDisplayCurrency}
+        <small class="opacity-50 ml-1">({sourceCurrency})</small>
+    {/if}
+</data>

package/src/runes/plugins/money/src/MoneyInput.svelte

@@ -0,0 +1,208 @@
+<script module lang="ts">
+    import type { ISO4217Code } from "@rune-lab/money";
+    import { MoneyPrimitive } from "@rune-lab/money";
+
+    export interface MoneyInputProps {
+        /** Current value in minor or major units (see unit prop) */
+        amount?: number | null | undefined;
+        /**
+         * MoneyPrimitive instance. When provided, initial amount and currency
+         * are derived from the primitive. Read-only input — output still fires oninput().
+         */
+        money?: MoneyPrimitive;
+        /**
+         * Whether the amount is in 'major' (e.g., pesos) or 'minor' (e.g., centavos) units.
+         * @deprecated Use `money` prop with MoneyPrimitive instead.
+         * Defaults to 'minor' for backward compatibility.
+         */
+        unit?: "major" | "minor";
+        /** Override currency code (defaults to CurrencyStore.current) */
+        currency?: ISO4217Code | string;
+        /** The currency the amount is stored in (e.g. MXN) */
+        storageCurrency?: ISO4217Code | string;
+        /** Minimum value in same units as amount (in storageCurrency) */
+        min?: number;
+        /** Maximum value in same units as amount (in storageCurrency) */
+        max?: number;
+        /** Placeholder text */
+        placeholder?: string;
+        /** Fired when the value changes (unit matches the unit prop, in storageCurrency) */
+        oninput?: (val: number) => void;
+        /** Input disabled state */
+        disabled?: boolean;
+    }
+</script>
+
+<script lang="ts">
+    import { getCurrencyStore } from "@rune-lab/kernel";
+    import { toMinorUnit } from "@rune-lab/money";
+    import { DEV } from "esm-env";
+
+    let {
+        amount = $bindable(0),
+        money,
+        unit = "minor",
+        currency,
+        storageCurrency,
+        min,
+        max,
+        placeholder = "0.00",
+        oninput,
+        disabled = false,
+    }: MoneyInputProps = $props();
+
+    const currencyStore = getCurrencyStore();
+
+    // Dev warning for deprecated usage
+    $effect(() => {
+        if (DEV && money && unit !== "minor") {
+            console.warn(
+                "[MoneyInput] The `unit` prop is deprecated when using `money: MoneyPrimitive`. " +
+                    "The unit is derived from the MoneyPrimitive instance.",
+            );
+        }
+    });
+
+    // Seed initial values from MoneyPrimitive if provided
+    $effect(() => {
+        if (money && amount === 0) {
+            amount = money.minor;
+        }
+    });
+
+    const resolvedDisplayCurrency = $derived(
+        money?.currencyCode ?? currency ?? String(currencyStore.current),
+    );
+
+    const resolvedStorageCurrency = $derived(
+        storageCurrency ?? money?.currencyCode ?? resolvedDisplayCurrency,
+    );
+
+    const displayMeta = $derived(currencyStore.get(resolvedDisplayCurrency));
+    const symbol = $derived(displayMeta?.symbol ?? "$");
+    const decimals = $derived(displayMeta?.decimals ?? 2);
+
+    // The display value is reactive to amount (which is in storage currency)
+    const displayValue = $derived.by(() => {
+        let val = amount ?? 0;
+
+        // If storage !== display, convert for display
+        if (
+            resolvedStorageCurrency !== resolvedDisplayCurrency &&
+            currencyStore.canConvert
+        ) {
+            const minorAmount =
+                unit === "major"
+                    ? toMinorUnit(val, resolvedStorageCurrency)
+                    : val;
+            const convertedMinor = currencyStore.convertAmount(
+                Number(minorAmount),
+                resolvedStorageCurrency,
+                resolvedDisplayCurrency,
+            );
+
+            if (decimals === 0) return String(Math.round(convertedMinor));
+            return (convertedMinor / Math.pow(10, decimals)).toFixed(decimals);
+        }
+
+        // Standard display (no conversion or no rates)
+        if (unit === "major") {
+            return Number(val).toFixed(decimals);
+        }
+        if (decimals === 0) return String(val);
+        const divisor = Math.pow(10, decimals);
+        return (Number(val) / divisor).toFixed(decimals);
+    });
+
+    function handleInput(e: Event) {
+        const target = e.target as HTMLInputElement;
+        const raw = target.value.replace(/[^0-9.,-]/g, "");
+
+        if (!raw) {
+            amount = 0;
+            oninput?.(0);
+            return;
+        }
+
+        // String-based parsing: split on decimal point
+        const parts = raw.split(".");
+        const integerPart = parts[0] || "0";
+
+        // Pad or truncate the fractional part to exactly `decimals` digits
+        let fractionalPart = (parts[1] || "").slice(0, decimals);
+        fractionalPart = fractionalPart.padEnd(decimals, "0");
+
+        // Combine as integer minor units (in display currency)
+        const combined =
+            decimals === 0 ? integerPart : integerPart + fractionalPart;
+
+        let displayCents = parseInt(combined, 10);
+        if (isNaN(displayCents)) return;
+
+        // Convert back to storage currency
+        let storageCents = displayCents;
+        if (
+            resolvedStorageCurrency !== resolvedDisplayCurrency &&
+            currencyStore.canConvert
+        ) {
+            storageCents = currencyStore.convertAmount(
+                displayCents,
+                resolvedDisplayCurrency,
+                resolvedStorageCurrency,
+            );
+        }
+
+        // Apply constraints in storage currency minor units
+        let finalStorageCents = storageCents;
+
+        const storageDecimals =
+            currencyStore.get(resolvedStorageCurrency)?.decimals ?? 2;
+        const minCents =
+            min !== undefined
+                ? unit === "major"
+                    ? toMinorUnit(min, resolvedStorageCurrency)
+                    : min
+                : undefined;
+        const maxCents =
+            max !== undefined
+                ? unit === "major"
+                    ? toMinorUnit(max, resolvedStorageCurrency)
+                    : max
+                : undefined;
+
+        if (minCents !== undefined)
+            finalStorageCents = Math.max(finalStorageCents, minCents);
+        if (maxCents !== undefined)
+            finalStorageCents = Math.min(finalStorageCents, maxCents);
+
+        if (unit === "major") {
+            const majorValue =
+                finalStorageCents / Math.pow(10, storageDecimals);
+            amount = majorValue;
+            oninput?.(majorValue);
+        } else {
+            amount = finalStorageCents;
+            oninput?.(finalStorageCents);
+        }
+    }
+</script>
+
+<label
+    class="input input-bordered flex items-center gap-1"
+    class:input-disabled={disabled}
+>
+    <span class="text-base-content/50 font-medium select-none">{symbol}</span>
+    <input
+        type="text"
+        inputmode="decimal"
+        class="grow bg-transparent outline-none tabular-nums"
+        value={displayValue}
+        {placeholder}
+        {disabled}
+        oninput={handleInput}
+        aria-label={`Amount in ${resolvedDisplayCurrency}`}
+    />
+    <span class="text-base-content/30 text-xs font-mono select-none"
+        >{resolvedDisplayCurrency}</span
+    >
+</label>

package/src/runes/plugins/money/src/currency.svelte.ts

@@ -0,0 +1,95 @@
+import {
+  type ConfigStore,
+  createConfigStore,
+  getCurrencyStore,
+} from "@rune-lab/kernel";
+import type { Currency } from "@rune-lab/kernel";
+import { type DineroCurrency, registerCurrency } from "@rune-lab/money";
+import type { ExchangeRateStore } from "./exchange-rate.svelte.ts";
+
+export type { Currency };
+
+/**
+ * Helper to build a minimal Dinero definition from Currency metadata.
+ * Assumes base 10 (standard decimal) for auto-registration.
+ */
+function buildDineroDef(meta: Currency) {
+  return {
+    code: meta.code,
+    base: 10,
+    exponent: meta.decimals,
+  };
+}
+
+const CURRENCIES: Currency[] = [
+  { 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 },
+] as const;
+
+const baseStore: ConfigStore<Currency> = createConfigStore<Currency>({
+  items: CURRENCIES,
+  storageKey: "currency",
+  displayName: "Currency",
+  idKey: "code",
+  icon: "💰",
+});
+
+// We hold a reference to exchangeRateStore if configured later
+let _exchangeRateStore: ExchangeRateStore | undefined;
+export function setExchangeRateStore(store: ExchangeRateStore) {
+  _exchangeRateStore = store;
+}
+
+/**
+ * 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 @rune-lab/kernel explicitly before addItems().
+ */
+function addCurrency(meta: Currency, dineroDef?: unknown) {
+  const def = dineroDef || buildDineroDef(meta);
+  registerCurrency(meta.code, def as DineroCurrency<number>);
+  baseStore.addItems([meta]);
+}
+
+/**
+ * Converts an amount from one currency to another.
+ * Defaults to converting to the current store currency.
+ */
+function convertAmount(
+  amount: number,
+  fromCode: string,
+  toCode?: string,
+): number {
+  const target = toCode ?? String((baseStore as ConfigStore<Currency>).current);
+  if (fromCode === target) return amount;
+  if (!_exchangeRateStore || !_exchangeRateStore.hasRates) return amount;
+
+  return _exchangeRateStore.convertAmount(amount, fromCode, target);
+}
+
+export const currencyStore: ConfigStore<Currency> & {
+  addCurrency: typeof addCurrency;
+  convertAmount: typeof convertAmount;
+  readonly canConvert: boolean;
+} = Object.assign(baseStore, {
+  addCurrency,
+  convertAmount,
+  get canConvert() {
+    return !!_exchangeRateStore?.hasRates;
+  },
+});
+
+export type CurrencyStore = typeof currencyStore;
+
+export { getCurrencyStore };

package/src/runes/plugins/money/src/currency.test.ts

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

package/src/runes/plugins/money/src/exchange-rate.svelte.ts

@@ -0,0 +1,176 @@
+// sdk/state/src/exchange-rate.svelte.ts
+
+import { getContext } from "svelte";
+import {
+  convertMoney,
+  createMoney,
+  CURRENCY_MAP,
+  directConversion,
+  inverseConversion,
+  type RateMap,
+  resolveRate,
+  type ScaledRate,
+  scaledRate,
+  toMoneySnapshot,
+  triangularConversion,
+} from "@rune-lab/money";
+import { RUNE_LAB_CONTEXT } from "@rune-lab/kernel";
+
+export class ExchangeRateStore {
+  #rates = $state<RateMap>({});
+  #baseCurrency = $state<string>("USD");
+
+  /**
+   * The current exchange rates relative to the base currency.
+   */
+  get rates(): RateMap {
+    return this.#rates;
+  }
+
+  /**
+   * The base currency all rates are relative to.
+   */
+  get baseCurrency(): string {
+    return this.#baseCurrency;
+  }
+
+  /**
+   * Returns true if exchange rates have been loaded.
+   */
+  get hasRates(): boolean {
+    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: string, rawRates: Record<string, number>) {
+    const nextRates: RateMap = {};
+    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: string, rates: RateMap) {
+    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: string, toCode: string): ScaledRate | number | undefined {
+    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.
+   * Delegates all math to ConversionStrategies (directConversion, inverseConversion, triangularConversion).
+   */
+  convertAmount(amount: number, fromCode: string, toCode: string): number {
+    if (fromCode === toCode) return amount;
+    if (!this.hasRates) return amount;
+
+    // Direct: Base → Target
+    if (fromCode === this.#baseCurrency) {
+      const rateToTarget = this.#rates[toCode];
+      if (!rateToTarget) return amount;
+      return directConversion(amount, resolveRate(rateToTarget));
+    }
+
+    // Inverse: Target → Base
+    if (toCode === this.#baseCurrency) {
+      const rateFromSource = this.#rates[fromCode];
+      if (!rateFromSource) return amount;
+      return inverseConversion(amount, resolveRate(rateFromSource));
+    }
+
+    // Triangulation: From → Base → To
+    const rateFromSource = this.#rates[fromCode];
+    const rateToTarget = this.#rates[toCode];
+    if (!rateFromSource || !rateToTarget) return amount;
+
+    return triangularConversion(
+      amount,
+      resolveRate(rateFromSource),
+      resolveRate(rateToTarget),
+    );
+  }
+}
+
+/**
+ * Factory to create the ExchangeRateStore.
+ */
+export function createExchangeRateStore(): ExchangeRateStore {
+  return new ExchangeRateStore();
+}
+
+/**
+ * Consumer to retrieve the ExchangeRateStore from context.
+ */
+export function getExchangeRateStore(): ExchangeRateStore {
+  return getContext<ExchangeRateStore>(RUNE_LAB_CONTEXT.exchangeRate);
+}