rune-lab 0.3.1 → 0.4.1

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

@@ -0,0 +1,95 @@
+// sdk/core/src/exchange-rate/strategies.ts
+// Pure conversion strategy functions — no store or context dependencies.
+// Extracted from ExchangeRateStore to enable independent testing and extensibility.
+
+import type { ScaledRate } from "./money.ts";
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+/**
+ * A pure function that converts a minor-unit amount using a rate.
+ * All strategy functions must be deterministic and side-effect-free.
+ */
+export type ConversionFn = (amount: number, ...rates: number[]) => number;
+
+/**
+ * Resolves a ScaledRate or plain number into a float rate value.
+ */
+export function resolveRate(rate: ScaledRate | number): number {
+  if (typeof rate === "number") return rate;
+  return rate.amount / Math.pow(10, rate.scale);
+}
+
+// ── Strategy Functions ─────────────────────────────────────────────────────────
+
+/**
+ * Direct conversion: base currency → target currency.
+ * Multiplies the amount by the rate.
+ *
+ * @param amount - Minor-unit amount in the source currency
+ * @param rate - Conversion rate (1 source = `rate` target)
+ * @returns Minor-unit amount in the target currency
+ */
+export function directConversion(amount: number, rate: number): number {
+  return Math.round(amount * rate);
+}
+
+/**
+ * Inverse conversion: target currency → base currency.
+ * Divides the amount by the rate.
+ *
+ * @param amount - Minor-unit amount in the source currency
+ * @param rate - Conversion rate of source relative to base (1 base = `rate` source)
+ * @returns Minor-unit amount in the base currency
+ */
+export function inverseConversion(amount: number, rate: number): number {
+  if (rate === 0) {
+    throw new Error("Cannot perform inverse conversion with a rate of zero.");
+  }
+  return Math.round(amount / rate);
+}
+
+/**
+ * Triangular conversion: source → base → target (cross-rate).
+ * First divides by the source-to-base rate, then multiplies by the base-to-target rate.
+ *
+ * @param amount - Minor-unit amount in the source currency
+ * @param rateSourceToBase - Rate of source relative to base (1 base = `rate` source)
+ * @param rateBaseToTarget - Rate of base to target (1 base = `rate` target)
+ * @returns Minor-unit amount in the target currency
+ */
+export function triangularConversion(
+  amount: number,
+  rateSourceToBase: number,
+  rateBaseToTarget: number,
+): number {
+  if (rateSourceToBase === 0) {
+    throw new Error(
+      "Cannot perform triangular conversion: source-to-base rate is zero.",
+    );
+  }
+  const amountInBase = amount / rateSourceToBase;
+  return Math.round(amountInBase * rateBaseToTarget);
+}
+
+// ── Strategy Registry ──────────────────────────────────────────────────────────
+
+/**
+ * Named map of conversion strategies.
+ * Consumer code and the ExchangeRateStore can select a strategy by name.
+ * Extensible: register additional strategies before store initialization.
+ *
+ * @example
+ * ```ts
+ * CONVERSION_STRATEGIES["crypto"] = (amount, rate) => {
+ *   // 18-decimal precision logic
+ * };
+ * ```
+ */
+export const CONVERSION_STRATEGIES: Record<string, ConversionFn> = {
+  direct: directConversion,
+  inverse: inverseConversion,
+  // triangularConversion takes 2 rates — wrapped for the registry signature
+  triangular: (amount: number, ...rates: number[]) =>
+    triangularConversion(amount, rates[0], rates[1]),
+};

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

@@ -0,0 +1,27 @@
+export {
+  addMoney,
+  convertAmount,
+  convertMoney,
+  createMoney,
+  CURRENCY_MAP,
+  type Dinero,
+  type DineroCurrency,
+  type DineroSnapshot,
+  formatAmount,
+  formatMoney,
+  fromMoneySnapshot,
+  type ISO4217Code,
+  multiplyMoney,
+  type RateMap,
+  registerCurrency,
+  safeAmount,
+  type ScaledRate,
+  scaledRate,
+  subtractMoney,
+  toAdyenMoney,
+  toMinorUnit,
+  toMoneySnapshot,
+  toPaypalMoney,
+  toSquareMoney,
+  toStripeMoney,
+} from "./money.ts";

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

@@ -0,0 +1,261 @@
+// sdk/state/src/composables/useMoney.ts
+// Context-aware money composable that reads CurrencyStore + LanguageStore
+
+import { getContext } from "svelte";
+import { RUNE_LAB_CONTEXT } from "@rune-lab/kernel";
+import type { ConfigStore } from "@rune-lab/kernel";
+import {
+  addMoney,
+  convertMoney,
+  createMoney,
+  formatMoney,
+  multiplyMoney,
+  subtractMoney,
+  toAdyenMoney,
+  toMinorUnit,
+  toMoneySnapshot,
+  toPaypalMoney,
+  toSquareMoney,
+  toStripeMoney,
+} from "@rune-lab/money";
+import type {
+  CurrencyStore,
+  Dinero,
+  ExchangeRateStore,
+  ISO4217Code,
+} from "@rune-lab/money";
+
+export interface UseMoneyReturn {
+  toDinero: (
+    amount: number | null | undefined,
+    currencyCode?: ISO4217Code | string,
+    unit?: "major" | "minor",
+  ) => Dinero<number>;
+  format: (
+    amount: number | null | undefined,
+    currencyCode?: ISO4217Code | string,
+    unit?: "major" | "minor",
+    localeOverride?: string,
+  ) => string;
+  add: (
+    a: number,
+    b: number,
+    currencyCode?: ISO4217Code | string,
+    unit?: "major" | "minor",
+  ) => Dinero<number>;
+  subtract: (
+    a: number,
+    b: number,
+    currencyCode?: ISO4217Code | string,
+    unit?: "major" | "minor",
+  ) => Dinero<number>;
+  convert: (
+    amount: number,
+    fromCode: string,
+    unit?: "major" | "minor",
+  ) => Dinero<number>;
+  formatConverted: (
+    amount: number,
+    fromCode: string,
+    unit?: "major" | "minor",
+  ) => string;
+  toPayload: (
+    amount: number,
+    currencyCode?: string,
+    target?: "stripe" | "paypal" | "adyen" | "square",
+    unit?: "major" | "minor",
+  ) =>
+    | { amount: number; currency: string }
+    | { value: string; currency_code: string }
+    | { value: number; currency: string }
+    | { amount: bigint; currency: string };
+  multiply: (
+    amount: number,
+    factor: number,
+    currencyCode?: ISO4217Code | string,
+    unit?: "major" | "minor",
+  ) => Dinero<number>;
+}
+
+/**
+ * Context-aware money composable.
+ * Reads CurrencyStore and LanguageStore from rune-lab context.
+ *
+ * Usage:
+ *   const { format, toDinero, add, subtract, convert } = useMoney();
+ *   const display = format(150.00, undefined, 'major'); // "$150.00"
+ */
+export function useMoney(): UseMoneyReturn {
+  const currencyStore = getContext<CurrencyStore>(RUNE_LAB_CONTEXT.currency);
+  const languageStore = getContext<ConfigStore<unknown>>(
+    RUNE_LAB_CONTEXT.language,
+  );
+  const exchangeRateStore = getContext<ExchangeRateStore>(
+    RUNE_LAB_CONTEXT.exchangeRate,
+  );
+
+  /**
+   * Convert amount to a Dinero object using current currency
+   */
+  function toDinero(
+    amount: number | null | undefined,
+    currencyCode?: ISO4217Code | string,
+    unit: "major" | "minor" = "minor",
+  ): Dinero<number> {
+    const code = currencyCode ?? String(currencyStore.current);
+    const minorAmount =
+      unit === "major" && amount !== null && amount !== undefined
+        ? toMinorUnit(Number(amount), code)
+        : amount;
+    return createMoney(minorAmount, code);
+  }
+
+  /**
+   * Format an amount as a locale-aware currency string
+   */
+  function format(
+    amount: number | null | undefined,
+    currencyCode?: ISO4217Code | string,
+    unit: "major" | "minor" = "minor",
+    localeOverride?: string,
+  ): string {
+    if (
+      amount === null || amount === undefined ||
+      (typeof amount === "number" && isNaN(amount))
+    ) {
+      return "—";
+    }
+
+    const code = currencyCode ?? String(currencyStore.current);
+    const locale = localeOverride ?? (String(languageStore.current) || "en");
+
+    const minorAmount = unit === "major"
+      ? toMinorUnit(Number(amount), code)
+      : amount;
+
+    const money = createMoney(minorAmount, code);
+    return formatMoney(money, locale, code);
+  }
+
+  /**
+   * Converts an amount from fromCode to the current display currency.
+   */
+  function convert(
+    amount: number,
+    fromCode: string,
+    unit: "major" | "minor" = "minor",
+  ): Dinero<number> {
+    const minorAmount = unit === "major"
+      ? toMinorUnit(amount, fromCode)
+      : amount;
+    const currentCode = String(currencyStore.current);
+
+    if (!exchangeRateStore?.hasRates || fromCode === currentCode) {
+      return createMoney(minorAmount, fromCode);
+    }
+
+    const sourceMoney = createMoney(minorAmount, fromCode);
+    return convertMoney(sourceMoney, currentCode, exchangeRateStore.rates);
+  }
+
+  /**
+   * Convenience: converts and formats an amount in one go.
+   */
+  function formatConverted(
+    amount: number,
+    fromCode: string,
+    unit: "major" | "minor" = "minor",
+  ): string {
+    const money = convert(amount, fromCode, unit);
+    const locale = String(languageStore.current) || "en";
+    const currentCode = String(currencyStore.current);
+    const snapshot = toMoneySnapshot(money);
+
+    // If conversion didn't happen (no rates), format as original currency
+    const displayCode = exchangeRateStore?.hasRates
+      ? currentCode
+      : snapshot.currency;
+
+    return formatMoney(money, locale, displayCode);
+  }
+
+  /**
+   * Multiply an amount by a factor.
+   */
+  function multiply(
+    amount: number,
+    factor: number,
+    currencyCode?: ISO4217Code | string,
+    unit: "major" | "minor" = "minor",
+  ): Dinero<number> {
+    const money = toDinero(amount, currencyCode, unit);
+    return multiplyMoney(money, factor);
+  }
+
+  /**
+   * Format an amount for a specific payment provider payload.
+   */
+  function toPayload(
+    amount: number,
+    currencyCode?: string,
+    target: "stripe" | "paypal" | "adyen" | "square" = "stripe",
+    unit: "major" | "minor" = "minor",
+  ) {
+    const code = currencyCode ?? String(currencyStore.current);
+    const money = toDinero(amount, code, unit);
+
+    switch (target) {
+      case "stripe":
+        return toStripeMoney(money);
+      case "paypal":
+        return toPaypalMoney(money);
+      case "adyen":
+        return toAdyenMoney(money);
+      case "square":
+        return toSquareMoney(money);
+      default:
+        return toStripeMoney(money);
+    }
+  }
+
+  /**
+   * Add two amounts in the current currency
+   */
+  function add(
+    a: number,
+    b: number,
+    currencyCode?: ISO4217Code | string,
+    unit: "major" | "minor" = "minor",
+  ): Dinero<number> {
+    const code = currencyCode ?? String(currencyStore.current);
+    const aMoney = toDinero(a, code, unit);
+    const bMoney = toDinero(b, code, unit);
+    return addMoney(aMoney, bMoney);
+  }
+
+  /**
+   * Subtract two amounts in the current currency
+   */
+  function subtract(
+    a: number,
+    b: number,
+    currencyCode?: ISO4217Code | string,
+    unit: "major" | "minor" = "minor",
+  ): Dinero<number> {
+    const code = currencyCode ?? String(currencyStore.current);
+    const aMoney = toDinero(a, code, unit);
+    const bMoney = toDinero(b, code, unit);
+    return subtractMoney(aMoney, bMoney);
+  }
+
+  return {
+    toDinero,
+    format,
+    add,
+    subtract,
+    convert,
+    formatConverted,
+    toPayload,
+    multiply,
+  };
+}

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

@@ -0,0 +1,132 @@
+// sdk/state/src/composables/useMoneyFilter.ts
+
+import { getContext, untrack } from "svelte";
+import { RUNE_LAB_CONTEXT } from "@rune-lab/kernel";
+import type { CurrencyStore } from "@rune-lab/money";
+import { useMoney } from "./useMoney.ts";
+
+export interface MoneyFilterOptions {
+  min?: number;
+  max?: number;
+  unit?: "major" | "minor";
+  autoConvertOnChange?: boolean;
+}
+
+export interface UseMoneyFilterReturn {
+  min: number;
+  max: number;
+  readonly displayMin: string;
+  readonly displayMax: string;
+  setMin: (value: number) => void;
+  setMax: (value: number) => void;
+  reset: () => void;
+  matches: (amount: number, entityCurrency: string) => boolean;
+}
+
+/**
+ * A reactive currency-aware filter composable.
+ * Handles min/max thresholds that auto-convert when the display currency changes.
+ */
+export function useMoneyFilter(
+  options: MoneyFilterOptions = {},
+): UseMoneyFilterReturn {
+  const currencyStore = getContext<CurrencyStore>(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 = $state(String(currencyStore.current));
+
+  $effect(() => {
+    const currentCurrency = String(currencyStore.current);
+    const previousCurrency = untrack(() => lastCurrency);
+
+    if (autoConvertOnChange && currentCurrency !== previousCurrency) {
+      if (currencyStore.canConvert) {
+        if (min !== 0) {
+          min = currencyStore.convertAmount(
+            min,
+            previousCurrency,
+            currentCurrency,
+          );
+        }
+        if (max !== Infinity) {
+          max = currencyStore.convertAmount(
+            max,
+            previousCurrency,
+            currentCurrency,
+          );
+        }
+      } else {
+        // Reset if no rates available
+        min = 0;
+        max = Infinity;
+      }
+      untrack(() => {
+        lastCurrency = currentCurrency;
+      });
+    }
+  });
+
+  function setMin(value: number) {
+    min = value;
+  }
+
+  function setMax(value: number) {
+    max = value;
+  }
+
+  function reset() {
+    min = 0;
+    max = Infinity;
+  }
+
+  /**
+   * Checks if an amount (in its entity currency) matches the current filter.
+   */
+  function matches(amount: number, entityCurrency: string): boolean {
+    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/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext",
+      "DOM",
+      "DOM.Iterable",
+      "DOM.AsyncIterable"
+    ],
+    // Set modern JS target
+    "target": "ESNext",
+    "module": "ESNext",
+    // Resolution & Extensions
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@rune-lab/kernel": [
+        "./src/kernel/src/mod.ts"
+      ],
+      "@rune-lab/layout": [
+        "./src/runes/layout/src/mod.ts"
+      ],
+      "@rune-lab/palettes": [
+        "./src/runes/palettes/src/mod.ts"
+      ],
+      "@rune-lab/money": [
+        "./src/runes/plugins/money/src/mod.ts"
+      ],
+      "@rune-lab/i18n/*": [
+        "./src/i18n/*"
+      ]
+    }
+  },
+  "exclude": [
+    "scripts/**",
+    "dist/**",
+    ".old/**",
+    "**/*.test.ts"
+  ]
+}

package/vite.config.ts

@@ -0,0 +1,44 @@
+// vite plus
+import { defineConfig } from "vite-plus";
+// customization
+import tailwindcss from "@tailwindcss/vite";
+import { paraglideVitePlugin } from "@inlang/paraglide-js";
+// main framework
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+
+export default defineConfig({
+  plugins: [
+    svelte(),
+    tailwindcss(),
+    paraglideVitePlugin({
+      project: "./src/i18n/project.inlang",
+      outdir: "./src/i18n/paraglide",
+    }),
+  ],
+  test: {
+    environment: "jsdom",
+    setupFiles: ["@testing-library/jest-dom/vitest"],
+  },
+  build: {
+    lib: {
+      entry: "./src/mod.ts",
+      formats: ["es"],
+    },
+    outDir: "dist",
+    rollupOptions: {
+      external: [
+        "svelte",
+        /^svelte\//,
+        "esm-env",
+        /^@sveltejs\//,
+        /^@inlang\//,
+        "hotkeys-js",
+      ],
+      output: {
+        preserveModules: true,
+        preserveModulesRoot: "src",
+        entryFileNames: "[name].ts",
+      },
+    },
+  },
+});

package/dist/core/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./internal/message-resolver";
-export * from "./persistence/types";
-export * from "./money/index";
-//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/core/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAE5C,cAAc,qBAAqB,CAAC;AAEpC,cAAc,eAAe,CAAC"}

package/dist/core/index.js

@@ -1,3 +0,0 @@
-export * from "./internal/message-resolver";
-export * from "./persistence/types";
-export * from "./money/index";

package/dist/core/internal/message-resolver.d.ts

@@ -1,42 +0,0 @@
-/**
- * Dynamic i18n Message Resolver Pattern
- *
- * Enables dynamic message function calls for config selectors.
- * Creates a resolver that dynamically looks up and calls message functions.
- */
-type MessageBundle = Record<string, (...args: any[]) => string>;
-interface MessageResolverConfig<T> {
-    /**
-     * Function to extract the message key from an option
-     * @example (currency) => currency.code // "USD"
-     */
-    keyExtractor: (option: T) => string;
-    /**
-     * Optional transformer for the key before message lookup
-     * @example (key) => key.toLowerCase() // "USD" -> "usd"
-     */
-    keyTransformer?: (key: string) => string;
-}
-/**
- * Creates a message resolver function for dynamic i18n lookups
- *
- * @example
- * ```typescript
- * const getCurrencyLabel = createMessageResolver<Currency>(m, {
- *   keyExtractor: (currency) => currency.code
- * });
- *
- * getCurrencyLabel({ code: "EUR", symbol: "€" }); // "Euro"
- * ```
- */
-export declare function createMessageResolver<T>(messages: MessageBundle, config: MessageResolverConfig<T>): (option: T) => string;
-/**
- * Type guard to check if a message key exists
- */
-export declare function hasMessage(messages: MessageBundle, key: string): boolean;
-/**
- * Batch resolver for multiple options at once
- */
-export declare function batchResolveMessages<T>(messages: MessageBundle, options: T[], config: MessageResolverConfig<T>): Record<string, string>;
-export {};
-//# sourceMappingURL=message-resolver.d.ts.map

package/dist/core/internal/message-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message-resolver.d.ts","sourceRoot":"","sources":["../../../src/sdk/core/src/internal/message-resolver.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC,CAAC;AAEhE,UAAU,qBAAqB,CAAC,CAAC;IAC/B;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IAEpC;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;CAC1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,IAExB,QAAQ,CAAC,KAAG,MAAM,CAmB3B;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAExE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,CAAC,EAAE,EACZ,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAC/B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQxB"}