rune-lab 0.4.0 → 0.4.1

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/design-tokens/props.d.ts

@@ -1,52 +0,0 @@
-/** Standard size scale used across all components. */
-export type SizeToken = "xs" | "sm" | "md" | "lg" | "xl";
-/** Mixin interface for components that accept a size prop. */
-export interface WithSizing {
-    /** Visual size variant. Defaults to "md" if omitted. */
-    size?: SizeToken;
-}
-/**
- * Semantic variant tokens aligned with DaisyUI's theme system.
- * Kept as a union type for TypeScript inference; consumers can extend via
- * `string & {}` if they need custom variants.
- */
-export type VariantToken = "primary" | "secondary" | "accent" | "neutral" | "ghost" | "info" | "success" | "warning" | "error";
-/** Mixin interface for components that accept a variant prop. */
-export interface WithVariant {
-    /** Semantic color variant. */
-    variant?: VariantToken;
-}
-/** Mixin interface for components that accept a custom CSS class. */
-export interface WithClass {
-    /** Additional CSS class string to merge with component classes. */
-    class?: string;
-}
-/**
- * Convenience intersection of all design-token mixins.
- * Use when a component supports size, variant, and custom class.
- */
-export type WithDesignTokens = WithSizing & WithVariant & WithClass;
-/**
- * Maps a size token to a CSS class string using a component-specific map.
- * Returns the mapped class or an empty string for unknown tokens.
- *
- * @param size - The size token to resolve
- * @param classMap - Component-specific mapping of tokens to CSS classes
- * @param fallback - Fallback size if `size` is undefined (default: "md")
- *
- * @example
- * ```ts
- * const btnSizeMap = { xs: "btn-xs", sm: "btn-sm", md: "btn-md", lg: "btn-lg", xl: "btn-xl" };
- * resolveSize("lg", btnSizeMap); // "btn-lg"
- * resolveSize(undefined, btnSizeMap); // "btn-md"
- * ```
- */
-export declare function resolveSize(size: SizeToken | undefined, classMap: Partial<Record<SizeToken, string>>, fallback?: SizeToken): string;
-/**
- * Maps a variant token to a CSS class string using a component-specific map.
- *
- * @param variant - The variant token to resolve
- * @param classMap - Component-specific mapping of tokens to CSS classes
- */
-export declare function resolveVariant(variant: VariantToken | undefined, classMap: Partial<Record<VariantToken, string>>): string;
-//# sourceMappingURL=props.d.ts.map

package/dist/core/design-tokens/props.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/sdk/core/src/design-tokens/props.ts"],"names":[],"mappings":"AAMA,sDAAsD;AACtD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAEzD,8DAA8D;AAC9D,MAAM,WAAW,UAAU;IACzB,wDAAwD;IACxD,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAID;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACpB,SAAS,GACT,WAAW,GACX,QAAQ,GACR,SAAS,GACT,OAAO,GACP,MAAM,GACN,SAAS,GACT,SAAS,GACT,OAAO,CAAC;AAEZ,iEAAiE;AACjE,MAAM,WAAW,WAAW;IAC1B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAID,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACxB,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAID;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAC;AAIpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,GAAG,SAAS,EAC3B,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,EAC5C,QAAQ,GAAE,SAAgB,GACzB,MAAM,CAGR;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,YAAY,GAAG,SAAS,EACjC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,GAC9C,MAAM,CAGR"}

package/dist/core/design-tokens/props.js

@@ -1,34 +0,0 @@
-// sdk/core/src/design-tokens/props.ts
-// Canonical shared prop interfaces for design tokens.
-// No CSS-framework-specific logic here — class maps live in sdk/ui.
-// ── Resolution Utilities ───────────────────────────────────────────────────────
-/**
- * Maps a size token to a CSS class string using a component-specific map.
- * Returns the mapped class or an empty string for unknown tokens.
- *
- * @param size - The size token to resolve
- * @param classMap - Component-specific mapping of tokens to CSS classes
- * @param fallback - Fallback size if `size` is undefined (default: "md")
- *
- * @example
- * ```ts
- * const btnSizeMap = { xs: "btn-xs", sm: "btn-sm", md: "btn-md", lg: "btn-lg", xl: "btn-xl" };
- * resolveSize("lg", btnSizeMap); // "btn-lg"
- * resolveSize(undefined, btnSizeMap); // "btn-md"
- * ```
- */
-export function resolveSize(size, classMap, fallback = "md") {
-    const token = size ?? fallback;
-    return classMap[token] ?? "";
-}
-/**
- * Maps a variant token to a CSS class string using a component-specific map.
- *
- * @param variant - The variant token to resolve
- * @param classMap - Component-specific mapping of tokens to CSS classes
- */
-export function resolveVariant(variant, classMap) {
-    if (!variant)
-        return "";
-    return classMap[variant] ?? "";
-}

package/dist/core/exchange-rate/strategies.d.ts

@@ -1,52 +0,0 @@
-import type { ScaledRate } from "../money/money.ts";
-/**
- * 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 declare function resolveRate(rate: ScaledRate | number): number;
-/**
- * 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 declare function directConversion(amount: number, rate: number): number;
-/**
- * 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 declare function inverseConversion(amount: number, rate: number): number;
-/**
- * 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 declare function triangularConversion(amount: number, rateSourceToBase: number, rateBaseToTarget: number): number;
-/**
- * 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 declare const CONVERSION_STRATEGIES: Record<string, ConversionFn>;
-//# sourceMappingURL=strategies.d.ts.map

package/dist/core/exchange-rate/strategies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategies.d.ts","sourceRoot":"","sources":["../../../src/sdk/core/src/exchange-rate/strategies.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;AAE1E;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,CAG7D;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAQR;AAID;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAM9D,CAAC"}

package/dist/core/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./internal/message-resolver.ts";
-export * from "./persistence/types.ts";
-export * from "./money/index.ts";
-export { type MoneyJSON, MoneyPrimitive } from "./money/money-primitive.ts";
-export * from "./exchange-rate/strategies.ts";
-export * from "./design-tokens/props.ts";
-export * from "./layout/types.ts";
-export * from "./shortcuts/types.ts";
-//# 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,gCAAgC,CAAC;AAE/C,cAAc,wBAAwB,CAAC;AAEvC,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,KAAK,SAAS,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5E,cAAc,+BAA+B,CAAC;AAE9C,cAAc,0BAA0B,CAAC;AAEzC,cAAc,mBAAmB,CAAC;AAElC,cAAc,sBAAsB,CAAC"}

package/dist/core/index.js

@@ -1,8 +0,0 @@
-export * from "./internal/message-resolver.js";
-export * from "./persistence/types.js";
-export * from "./money/index.js";
-export { MoneyPrimitive } from "./money/money-primitive.js";
-export * from "./exchange-rate/strategies.js";
-export * from "./design-tokens/props.js";
-export * from "./layout/types.js";
-export * from "./shortcuts/types.js";

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: unknown[]) => 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