rune-lab 0.4.0 → 0.4.1

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);
+}

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

@@ -0,0 +1,95 @@
+import { describe, expect, it, vi } from "vite-plus/test";
+import { ExchangeRateStore } from "./exchange-rate.svelte.ts";
+import { currencyStore, setExchangeRateStore } from "./currency.svelte.ts";
+import { inMemoryDriver, RUNE_LAB_CONTEXT } from "@rune-lab/kernel";
+import { languageStore } from "../../../layout/src/language.svelte.ts";
+
+// Mock useMoney since it uses getContext and other stores
+vi.mock("./useMoney.ts", () => ({
+  useMoney: () => ({
+    format: (amount: number, code?: string, _unit?: unknown) =>
+      `${amount} ${code ?? "USD"}`,
+  }),
+}));
+
+describe("ExchangeRateStore", () => {
+  it("should initialize with default base", () => {
+    const store = new ExchangeRateStore();
+    expect(store.baseCurrency).toBe("USD");
+    expect(store.hasRates).toBe(false);
+  });
+
+  it("should set and retrieve rates", () => {
+    const store = new ExchangeRateStore();
+    store.setRates("USD", { MXN: 17.23, EUR: 0.91 });
+
+    expect(store.hasRates).toBe(true);
+    expect(store.baseCurrency).toBe("USD");
+
+    const rateToMxn = store.getRate("USD", "MXN");
+    expect(rateToMxn).toEqual({ amount: 17230000, scale: 6 });
+  });
+
+  it("should handle inverse rates", () => {
+    const store = new ExchangeRateStore();
+    store.setRates("USD", { MXN: 20 });
+
+    const rateToBase = store.getRate("MXN", "USD");
+    expect(rateToBase).toEqual({ amount: 5000000, scale: 8 });
+  });
+
+  it("should handle triangulation (cross-rates)", () => {
+    const store = new ExchangeRateStore();
+    store.setRates("USD", { MXN: 20, EUR: 0.5 });
+
+    const rateMxnToEur = store.getRate("MXN", "EUR");
+    expect(rateMxnToEur).toEqual({ amount: 2500000, scale: 8 });
+  });
+});
+
+describe("CurrencyStore Integration", () => {
+  it("should convert amount when ExchangeRateStore is wired", () => {
+    const exchangeRateStore = new ExchangeRateStore();
+    exchangeRateStore.setRates("USD", { MXN: 20 });
+
+    setExchangeRateStore(exchangeRateStore);
+
+    expect(currencyStore.canConvert).toBe(true);
+
+    const converted = currencyStore.convertAmount(10000, "USD", "MXN");
+    expect(converted).toBe(200000);
+  });
+
+  it("should return original amount if no rates available", () => {
+    const exchangeRateStore = new ExchangeRateStore();
+    setExchangeRateStore(exchangeRateStore);
+
+    expect(currencyStore.canConvert).toBe(false);
+
+    const converted = currencyStore.convertAmount(10000, "USD", "MXN");
+    expect(converted).toBe(10000);
+  });
+});
+
+describe("useMoneyFilter", () => {
+  // Simple test for logic, skipping full component mount for brevity
+  it("matches() should work with conversion", () => {
+    const exchangeRateStore = new ExchangeRateStore();
+    exchangeRateStore.setRates("USD", { MXN: 20 });
+
+    setExchangeRateStore(exchangeRateStore);
+
+    // Manual mock of context for the composable
+    // In a real test we'd use render() from @testing-library/svelte
+    const mockContext = new Map();
+    mockContext.set(RUNE_LAB_CONTEXT.currency, currencyStore);
+    mockContext.set(RUNE_LAB_CONTEXT.exchangeRate, exchangeRateStore);
+    mockContext.set(RUNE_LAB_CONTEXT.language, languageStore);
+
+    // We can't easily call useMoneyFilter outside component without more setup
+    // but we can verify the matches logic in CurrencyStore
+    const amountInMxn = 1000000; // 10,000 MXN
+    const amountInUsd = currencyStore.convertAmount(amountInMxn, "MXN", "USD");
+    expect(amountInUsd).toBe(50000); // 500 USD
+  });
+});

package/src/runes/plugins/money/src/mod.ts

@@ -0,0 +1,79 @@
+import { defineRune, RUNE_LAB_CONTEXT } from "@rune-lab/kernel";
+import type { PersistenceDriver, RunePlugin } from "@rune-lab/kernel";
+import {
+  type Currency,
+  currencyStore,
+  setExchangeRateStore,
+} from "./currency.svelte.ts";
+import { createExchangeRateStore } from "./exchange-rate.svelte.ts";
+import type { ExchangeRateStore } from "./exchange-rate.svelte.ts";
+
+export * from "./currency.svelte.ts";
+export * from "./exchange-rate.svelte.ts";
+export * from "./types.ts";
+export * from "./money.ts";
+export * from "./strategies.ts";
+export * from "./money-primitive.ts";
+export * from "./useMoney.ts";
+export * from "./useMoneyFilter.ts";
+
+interface MoneyConfig {
+  exchangeRates?: {
+    base: string;
+    rates: Record<string, number>;
+  };
+  currencies?: Currency[];
+  defaultCurrency?: string;
+}
+
+/**
+ * Money Plugin — provides currency management and exchange rate conversion.
+ */
+export const MoneyPlugin: RunePlugin = defineRune({
+  id: "rune-lab.money",
+  stores: [
+    {
+      id: "exchangeRate",
+      contextKey: RUNE_LAB_CONTEXT.exchangeRate,
+      factory: (config: unknown) => {
+        const store = createExchangeRateStore();
+        const c = config as MoneyConfig;
+        if (c?.exchangeRates) {
+          store.setRates(c.exchangeRates.base, c.exchangeRates.rates);
+        }
+        return store;
+      },
+      noPersistence: true,
+    },
+    {
+      id: "currency",
+      contextKey: RUNE_LAB_CONTEXT.currency,
+      factory: (
+        config: unknown,
+        _driver: PersistenceDriver,
+        stores: Map<string, unknown>,
+      ) => {
+        const c = config as MoneyConfig;
+        setExchangeRateStore(stores.get("exchangeRate") as ExchangeRateStore);
+
+        if (c?.currencies) {
+          for (const cur of c.currencies) {
+            currencyStore.addCurrency(cur);
+          }
+        }
+
+        if (
+          c?.defaultCurrency &&
+          !(currencyStore as unknown as { current: unknown }).current
+        ) {
+          if (currencyStore.get(c.defaultCurrency as never)) {
+            currencyStore.set(c.defaultCurrency as never);
+          }
+        }
+
+        return currencyStore;
+      },
+      dependsOn: ["exchangeRate"],
+    },
+  ],
+});

package/src/runes/plugins/money/src/money-primitive.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it } from "vite-plus/test";
+import { MoneyPrimitive } from "./money-primitive.ts";
+import { registerCurrency } from "./money.ts";
+
+describe("MoneyPrimitive", () => {
+  describe("Construction", () => {
+    it("should create from minor units", () => {
+      const money = MoneyPrimitive.fromMinor(1299, "USD");
+      expect(money.amount).toBe(1299);
+      expect(money.currencyCode).toBe("USD");
+      expect(money.scale).toBe(2);
+    });
+
+    it("should create from major units", () => {
+      const money = MoneyPrimitive.fromMajor(12.99, "USD");
+      expect(money.amount).toBe(1299);
+      expect(money.currencyCode).toBe("USD");
+      expect(money.scale).toBe(2);
+    });
+
+    it("should round fractional minor units", () => {
+      const money = MoneyPrimitive.fromMajor(12.999, "USD");
+      expect(money.amount).toBe(1300); // rounded
+    });
+
+    it("should throw for unknown currency", () => {
+      expect(() => MoneyPrimitive.fromMinor(100, "UNKNOWN")).toThrow(
+        "Unknown currency code",
+      );
+    });
+  });
+
+  describe("JPY (exponent 0)", () => {
+    it("should handle zero-exponent currencies", () => {
+      const yen = MoneyPrimitive.fromMinor(5000, "JPY");
+      expect(yen.minor).toBe(5000);
+      expect(yen.major).toBe(5000); // no decimal shift for JPY
+      expect(yen.scale).toBe(0);
+    });
+
+    it("should create from major with no decimal shift", () => {
+      const yen = MoneyPrimitive.fromMajor(5000, "JPY");
+      expect(yen.amount).toBe(5000);
+    });
+  });
+
+  describe("BHD (exponent 3)", () => {
+    it("should handle 3-exponent currencies", () => {
+      const BHD = { code: "BHD", base: 10, exponent: 3 };
+      registerCurrency("BHD", BHD);
+
+      const dinar = MoneyPrimitive.fromMajor(1.234, "BHD");
+      expect(dinar.amount).toBe(1234);
+      expect(dinar.major).toBe(1.234);
+      expect(dinar.scale).toBe(3);
+    });
+  });
+
+  describe("Getters", () => {
+    it(".minor returns the raw amount", () => {
+      const money = MoneyPrimitive.fromMinor(1500, "USD");
+      expect(money.minor).toBe(1500);
+    });
+
+    it(".major returns the human-readable float", () => {
+      const money = MoneyPrimitive.fromMinor(1500, "USD");
+      expect(money.major).toBe(15.0);
+    });
+
+    it(".major handles MXN (exponent 2)", () => {
+      const money = MoneyPrimitive.fromMinor(25050, "MXN");
+      expect(money.major).toBe(250.5);
+    });
+  });
+
+  describe("Formatting", () => {
+    it("should format USD in en-US", () => {
+      const money = MoneyPrimitive.fromMinor(1299, "USD");
+      expect(money.format("en-US")).toMatch(/\$12\.99/);
+    });
+
+    it("should format MXN in es-MX", () => {
+      const money = MoneyPrimitive.fromMinor(25050, "MXN");
+      expect(money.format("es-MX")).toMatch(/\$250\.50/);
+    });
+
+    it("should format JPY with no decimals", () => {
+      const money = MoneyPrimitive.fromMinor(5000, "JPY");
+      const formatted = money.format("ja-JP");
+      expect(formatted).toMatch(/5,000/);
+    });
+  });
+
+  describe("Arithmetic (immutability)", () => {
+    it("add returns a new instance", () => {
+      const a = MoneyPrimitive.fromMinor(1000, "USD");
+      const b = MoneyPrimitive.fromMinor(500, "USD");
+      const result = a.add(b);
+
+      expect(result.amount).toBe(1500);
+      expect(result).not.toBe(a); // new instance
+      expect(a.amount).toBe(1000); // original unchanged
+    });
+
+    it("subtract returns a new instance", () => {
+      const a = MoneyPrimitive.fromMinor(1000, "USD");
+      const b = MoneyPrimitive.fromMinor(300, "USD");
+      const result = a.subtract(b);
+
+      expect(result.amount).toBe(700);
+      expect(a.amount).toBe(1000);
+    });
+
+    it("multiply returns a new instance", () => {
+      const money = MoneyPrimitive.fromMinor(1000, "USD");
+      const result = money.multiply(2.5);
+
+      expect(result.amount).toBe(2500);
+      expect(money.amount).toBe(1000);
+    });
+
+    it("multiply rounds correctly", () => {
+      const money = MoneyPrimitive.fromMinor(100, "USD");
+      const result = money.multiply(0.33);
+
+      expect(result.amount).toBe(33);
+    });
+
+    it("throws on currency mismatch for add", () => {
+      const usd = MoneyPrimitive.fromMinor(100, "USD");
+      const eur = MoneyPrimitive.fromMinor(100, "EUR");
+
+      expect(() => usd.add(eur)).toThrow("Currency mismatch");
+    });
+
+    it("throws on currency mismatch for subtract", () => {
+      const usd = MoneyPrimitive.fromMinor(100, "USD");
+      const eur = MoneyPrimitive.fromMinor(100, "EUR");
+
+      expect(() => usd.subtract(eur)).toThrow("Currency mismatch");
+    });
+  });
+
+  describe("Comparison", () => {
+    it("equals returns true for identical values", () => {
+      const a = MoneyPrimitive.fromMinor(1000, "USD");
+      const b = MoneyPrimitive.fromMinor(1000, "USD");
+      expect(a.equals(b)).toBe(true);
+    });
+
+    it("equals returns false for different amounts", () => {
+      const a = MoneyPrimitive.fromMinor(1000, "USD");
+      const b = MoneyPrimitive.fromMinor(2000, "USD");
+      expect(a.equals(b)).toBe(false);
+    });
+
+    it("equals returns false for different currencies", () => {
+      const a = MoneyPrimitive.fromMinor(1000, "USD");
+      const b = MoneyPrimitive.fromMinor(1000, "EUR");
+      expect(a.equals(b)).toBe(false);
+    });
+
+    it("isZero returns true for zero amount", () => {
+      expect(MoneyPrimitive.fromMinor(0, "USD").isZero()).toBe(true);
+    });
+
+    it("isZero returns false for non-zero", () => {
+      expect(MoneyPrimitive.fromMinor(1, "USD").isZero()).toBe(false);
+    });
+
+    it("isNegative works correctly", () => {
+      expect(MoneyPrimitive.fromMinor(-100, "USD").isNegative()).toBe(true);
+      expect(MoneyPrimitive.fromMinor(0, "USD").isNegative()).toBe(false);
+      expect(MoneyPrimitive.fromMinor(100, "USD").isNegative()).toBe(false);
+    });
+  });
+
+  describe("Serialization (JSON round-trip)", () => {
+    it("should round-trip standard currency", () => {
+      const original = MoneyPrimitive.fromMinor(1299, "USD");
+      const json = original.toJSON();
+
+      expect(json).toEqual({
+        amount: 1299,
+        currencyCode: "USD",
+        scale: 2,
+      });
+
+      const restored = MoneyPrimitive.fromJSON(json);
+      expect(restored.equals(original)).toBe(true);
+    });
+
+    it("should round-trip JPY", () => {
+      const original = MoneyPrimitive.fromMinor(5000, "JPY");
+      const json = original.toJSON();
+      const restored = MoneyPrimitive.fromJSON(json);
+
+      expect(restored.amount).toBe(5000);
+      expect(restored.scale).toBe(0);
+      expect(restored.equals(original)).toBe(true);
+    });
+
+    it("should round-trip through JSON.stringify/parse", () => {
+      const original = MoneyPrimitive.fromMajor(42.5, "EUR");
+      const serialized = JSON.stringify(original);
+      const parsed = JSON.parse(serialized);
+      const restored = MoneyPrimitive.fromJSON(parsed);
+
+      expect(restored.equals(original)).toBe(true);
+    });
+
+    it("toString returns a debug-friendly string", () => {
+      const money = MoneyPrimitive.fromMinor(1299, "USD");
+      expect(money.toString()).toBe("MoneyPrimitive(1299 USD scale=2)");
+    });
+  });
+});