@merkaly/nuxt 0.8.1 → 0.9.1

package/README.md

@@ -21,3 +21,67 @@ A Nuxt module that provides Auth0 authentication integration and API utilities f
 ## Quick Setup
 
 Install the module to your Nuxt application:
+
+## Money formatting
+
+Money in Merkaly is stored as **integer cents**. `MKFormatMoney`, `MKInputMoney`,
+`formatMoney()` and `useMoneyFormat()` divide by 100 and format with
+`Intl.NumberFormat(locale, { style: 'currency', currency })`, so `24969` with
+`BRL` + `pt-BR` renders `R$ 249,69`.
+
+Currency and locale are resolved in this order:
+
+1. Component props: `<MKFormatMoney :value="24969" currency="BRL" locale="pt-BR" />`
+2. App-level default set at runtime with `setMoneyDefaults()` (stored with `useState`)
+3. Module option `merkaly.money` (runtime config)
+4. Fallback `USD` / `en-US`
+
+### Module option
+
+```ts
+export default defineNuxtConfig({
+  merkaly: {
+    money: {
+      currency: 'BRL', // ISO 4217
+      locale: 'pt-BR', // BCP 47
+    },
+  },
+});
+```
+
+It lives in `runtimeConfig.public.merkaly.money`, so it can also be set with
+`NUXT_PUBLIC_MERKALY_MONEY_CURRENCY` / `NUXT_PUBLIC_MERKALY_MONEY_LOCALE`.
+
+### Runtime default (per organization)
+
+```ts
+const { setMoneyDefaults } = useMoneyFormat();
+
+// after loading the organization
+setMoneyDefaults({
+  currency: organization.localization.currency, // e.g. 'BRL'
+  locale: organization.localization.language, // e.g. 'pt' or 'pt-BR'
+});
+```
+
+`useMoneyFormat()` returns:
+
+| Key | Description |
+| --- | --- |
+| `currency`, `locale` | Resolved defaults (computed) |
+| `setMoneyDefaults({ currency?, locale? })` | Sets the app-level default (merged) |
+| `resetMoneyDefaults()` | Clears the app-level default |
+| `format(cents, options?)` | Formatted string using the resolved defaults |
+| `formatParts(cents, options?)` | `{ prefix, amount, digits, suffix }` parts |
+
+`setMoneyDefaults(defaults)` is also auto-imported as a standalone shortcut.
+
+### Components
+
+- `MKFormatMoney`: props `value` (cents), `currency`, `locale`, `base` (default `100`),
+  `mode`, `hideDecimal`, `tag`. `currency` also accepts a plain symbol (`$`) for
+  backward compatibility: the number keeps the resolved currency layout and the
+  symbol replaces the currency sign.
+- `MKInputMoney`: `v-model` in cents; props `currency`, `locale`. `prefix`, `decimal`,
+  `thousands` and `placeholder` default to the resolved currency/locale and can still
+  be passed explicitly.

package/dist/module.d.mts

@@ -36,6 +36,18 @@ interface MerkalyModuleOptions {
          */
         strategy?: Strategies;
     };
+    /**
+     * Default currency/locale for `MKFormatMoney`, `MKInputMoney` and
+     * `useMoneyFormat()`. Apps can override it at runtime with
+     * `setMoneyDefaults()` (e.g. after loading the organization) and per
+     * component with the `currency` / `locale` props.
+     */
+    money?: {
+        /** ISO 4217 code, e.g. `BRL`. Defaults to `USD`. */
+        currency?: string;
+        /** BCP 47 locale, e.g. `pt-BR`. Defaults to `en-US`. */
+        locale?: string;
+    };
     plausible?: {
         domain: string;
         localhost: string;

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.14.0"
   },
-  "version": "0.8.1",
+  "version": "0.9.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -30,6 +30,10 @@ const defaultOptions = {
     locales: [],
     strategy: "no_prefix"
   },
+  money: {
+    currency: "USD",
+    locale: "en-US"
+  },
   plausible: {
     domain: "",
     localhost: ""
@@ -133,6 +137,7 @@ function configureRuntimeConfig(nuxt, options) {
       api: options.api,
       auth0: options.auth0,
       i18n: options.i18n,
+      money: options.money,
       plausible: options.plausible,
       sentry: {
         dsn: options.sentry.dsn,

package/dist/runtime/components/format/FormatMoney.d.vue.ts

@@ -4,17 +4,19 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: NumberConstructor;
         default: number;
     };
+    /** ISO 4217 code (`BRL`) or, for backward compatibility, a symbol (`$`). Falls back to the app default. */
     currency: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     hideDecimal: {
         type: BooleanConstructor;
         default: () => boolean;
     };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
     locale: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     mode: {
         type: PropType<Intl.NumberFormatOptionsStyle>;
@@ -33,17 +35,19 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: NumberConstructor;
         default: number;
     };
+    /** ISO 4217 code (`BRL`) or, for backward compatibility, a symbol (`$`). Falls back to the app default. */
     currency: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     hideDecimal: {
         type: BooleanConstructor;
         default: () => boolean;
     };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
     locale: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     mode: {
         type: PropType<Intl.NumberFormatOptionsStyle>;
@@ -61,10 +65,10 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     mode: keyof Intl.NumberFormatOptionsStyleRegistry;
     value: number;
     currency: string;
+    locale: string;
     base: number;
     tag: string;
     hideDecimal: boolean;
-    locale: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/format/FormatMoney.vue

@@ -1,33 +1,32 @@
 <script setup>
 import { computed } from "vue";
-import { formatMoney } from "../../utils/formatMoney";
+import { useMoneyFormat } from "../../composables/useMoneyFormat";
 const props = defineProps({
   base: { type: Number, default: 100 },
-  currency: { type: String, default: () => "USD" },
+  /** ISO 4217 code (`BRL`) or, for backward compatibility, a symbol (`$`). Falls back to the app default. */
+  currency: { type: String, default: void 0 },
   hideDecimal: { type: Boolean, default: () => false },
-  locale: { type: String, default: () => "en-US" },
+  /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
+  locale: { type: String, default: void 0 },
   mode: { type: String, default: "currency" },
   tag: { type: String, default: "span" },
   value: { type: Number, default: 0 }
 });
-const money = computed(() => formatMoney(props.value, {
+const { formatParts } = useMoneyFormat();
+const price = computed(() => formatParts(props.value, {
   base: props.base,
   currency: props.currency,
   locale: props.locale,
   mode: props.mode
 }));
-const price = computed(() => ({
-  currency: money.value[0],
-  amount: money.value.slice(1, -3),
-  digits: money.value.slice(-3)
-}));
 </script>
 
 <template>
-  <component :is="tag" class="format-money">
-    <span class="currency" v-text="price.currency" />
+  <component :is="props.tag" class="format-money">
+    <span v-if="price.prefix" class="currency" v-text="price.prefix" />
     <span class="value" v-text="price.amount" />
-    <sup v-if="!props.hideDecimal" class="digits" v-text="price.digits" />
+    <sup v-if="!props.hideDecimal && price.digits" class="digits" v-text="price.digits" />
+    <span v-if="price.suffix" class="currency" v-text="price.suffix" />
   </component>
 </template>
 

package/dist/runtime/components/format/FormatMoney.vue.d.ts

@@ -4,17 +4,19 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: NumberConstructor;
         default: number;
     };
+    /** ISO 4217 code (`BRL`) or, for backward compatibility, a symbol (`$`). Falls back to the app default. */
     currency: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     hideDecimal: {
         type: BooleanConstructor;
         default: () => boolean;
     };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
     locale: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     mode: {
         type: PropType<Intl.NumberFormatOptionsStyle>;
@@ -33,17 +35,19 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: NumberConstructor;
         default: number;
     };
+    /** ISO 4217 code (`BRL`) or, for backward compatibility, a symbol (`$`). Falls back to the app default. */
     currency: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     hideDecimal: {
         type: BooleanConstructor;
         default: () => boolean;
     };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
     locale: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     mode: {
         type: PropType<Intl.NumberFormatOptionsStyle>;
@@ -61,10 +65,10 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     mode: keyof Intl.NumberFormatOptionsStyleRegistry;
     value: number;
     currency: string;
+    locale: string;
     base: number;
     tag: string;
     hideDecimal: boolean;
-    locale: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/input/InputMoney.d.vue.ts

@@ -1,8 +1,18 @@
 import type { Numberish } from 'bootstrap-vue-next/dist/src/types/CommonTypes';
 declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** ISO 4217 code (`BRL`). Falls back to the app default. */
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
     decimal: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
+    };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
+    locale: {
+        type: StringConstructor;
+        default: undefined;
     };
     max: {
         type: NumberConstructor;
@@ -15,7 +25,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     placeholder: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     precision: {
         type: NumberConstructor;
@@ -23,7 +33,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     prefix: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     suffix: {
         type: StringConstructor;
@@ -31,15 +41,25 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     thousands: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     modelValue: Numberish;
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: Numberish) => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** ISO 4217 code (`BRL`). Falls back to the app default. */
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
     decimal: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
+    };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
+    locale: {
+        type: StringConstructor;
+        default: undefined;
     };
     max: {
         type: NumberConstructor;
@@ -52,7 +72,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     placeholder: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     precision: {
         type: NumberConstructor;
@@ -60,7 +80,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     prefix: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     suffix: {
         type: StringConstructor;
@@ -68,15 +88,17 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     thousands: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     modelValue: Numberish;
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: Numberish) => any) | undefined;
 }>, {
+    decimal: string;
+    currency: string;
+    locale: string;
     min: number;
     max: number;
-    decimal: string;
     placeholder: string;
     precision: number;
     prefix: string;

package/dist/runtime/components/input/InputMoney.vue

@@ -1,6 +1,8 @@
 <script setup>
 import { computed } from "vue";
 import { Money3Component } from "v-money3";
+import { useMoneyFormat } from "../../composables/useMoneyFormat";
+import { isCurrencyCode } from "../../utils/formatMoney";
 const money = defineModel({ type: null, ...{
   default: () => 0,
   get: (v) => v / 100,
@@ -8,21 +10,43 @@ const money = defineModel({ type: null, ...{
   type: [String, Number]
 } });
 const props = defineProps({
-  decimal: { type: String, default: () => "." },
+  /** ISO 4217 code (`BRL`). Falls back to the app default. */
+  currency: { type: String, default: void 0 },
+  decimal: { type: String, default: void 0 },
+  /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
+  locale: { type: String, default: void 0 },
   max: { type: Number, required: false, default: void 0 },
   min: { type: Number, default: () => 0 },
-  placeholder: { type: String, default: () => "$0.00" },
+  placeholder: { type: String, default: void 0 },
   precision: { type: Number, default: () => 2 },
-  prefix: { type: String, default: () => "$" },
+  prefix: { type: String, default: void 0 },
   suffix: { type: String, default: () => " " },
-  thousands: { type: String, default: () => "," }
+  thousands: { type: String, default: void 0 }
+});
+const { resolve, formatParts } = useMoneyFormat();
+const separators = computed(() => {
+  const options = resolve({ currency: props.currency, locale: props.locale });
+  const code = isCurrencyCode(options.currency) ? options.currency.toUpperCase() : options.symbolCurrency;
+  const parts = new Intl.NumberFormat(options.locale, { style: "currency", currency: code }).formatToParts(123456789e-2);
+  return {
+    decimal: parts.find((part) => part.type === "decimal")?.value ?? ".",
+    symbol: isCurrencyCode(options.currency) ? parts.find((part) => part.type === "currency")?.value ?? options.currency : options.currency,
+    thousands: parts.find((part) => part.type === "group")?.value ?? ","
+  };
+});
+const placeholder = computed(() => {
+  if (props.placeholder !== void 0) {
+    return props.placeholder;
+  }
+  const parts = formatParts(0, { currency: props.currency, locale: props.locale });
+  return parts.prefix + parts.amount + parts.digits + parts.suffix;
 });
 const config = computed(() => ({
-  decimal: props.decimal,
+  decimal: props.decimal ?? separators.value.decimal,
   precision: props.precision,
-  prefix: props.prefix.concat(" "),
+  prefix: (props.prefix ?? separators.value.symbol).concat(" "),
   suffix: props.suffix,
-  thousands: props.thousands
+  thousands: props.thousands ?? separators.value.thousands
 }));
 </script>
 
@@ -31,7 +55,7 @@ const config = computed(() => ({
       v-model.number="money"
       :max="props.max"
       :min="props.min"
-      :placeholder="props.placeholder"
+      :placeholder="placeholder"
       class="form-control"
       v-bind="config"
   />

package/dist/runtime/components/input/InputMoney.vue.d.ts

@@ -1,8 +1,18 @@
 import type { Numberish } from 'bootstrap-vue-next/dist/src/types/CommonTypes';
 declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** ISO 4217 code (`BRL`). Falls back to the app default. */
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
     decimal: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
+    };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
+    locale: {
+        type: StringConstructor;
+        default: undefined;
     };
     max: {
         type: NumberConstructor;
@@ -15,7 +25,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     placeholder: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     precision: {
         type: NumberConstructor;
@@ -23,7 +33,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     prefix: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     suffix: {
         type: StringConstructor;
@@ -31,15 +41,25 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     thousands: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     modelValue: Numberish;
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: Numberish) => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** ISO 4217 code (`BRL`). Falls back to the app default. */
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
     decimal: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
+    };
+    /** BCP 47 locale (`pt-BR`). Falls back to the app default. */
+    locale: {
+        type: StringConstructor;
+        default: undefined;
     };
     max: {
         type: NumberConstructor;
@@ -52,7 +72,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     placeholder: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     precision: {
         type: NumberConstructor;
@@ -60,7 +80,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     prefix: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     suffix: {
         type: StringConstructor;
@@ -68,15 +88,17 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     };
     thousands: {
         type: StringConstructor;
-        default: () => string;
+        default: undefined;
     };
     modelValue: Numberish;
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: Numberish) => any) | undefined;
 }>, {
+    decimal: string;
+    currency: string;
+    locale: string;
     min: number;
     max: number;
-    decimal: string;
     placeholder: string;
     precision: number;
     prefix: string;

package/dist/runtime/composables/useMoneyFormat.d.ts

@@ -0,0 +1,24 @@
+import { type FormatMoneyOptions } from '../utils/formatMoney.js';
+export interface MoneyDefaults {
+    /** ISO 4217 code, e.g. `BRL`. */
+    currency?: string;
+    /** BCP 47 locale, e.g. `pt-BR` (a bare language such as `pt` also works). */
+    locale?: string;
+}
+/**
+ * App-level money defaults used by `MKFormatMoney` / `MKInputMoney`.
+ *
+ * Resolution order: component props > `setMoneyDefaults()` (runtime, per app) >
+ * `merkaly.money` module option (runtime config) > `USD` / `en-US`.
+ */
+export declare const useMoneyFormat: () => {
+    currency: import("vue").ComputedRef<string>;
+    format: (value: number, options?: FormatMoneyOptions) => string;
+    formatParts: (value: number, options?: FormatMoneyOptions) => import("#imports").FormatMoneyParts;
+    locale: import("vue").ComputedRef<string>;
+    resetMoneyDefaults: () => void;
+    resolve: (options?: FormatMoneyOptions) => FormatMoneyOptions;
+    setMoneyDefaults: (defaults: MoneyDefaults) => void;
+};
+/** Shortcut for `useMoneyFormat().setMoneyDefaults(defaults)`. */
+export declare const setMoneyDefaults: (defaults: MoneyDefaults) => void;

package/dist/runtime/composables/useMoneyFormat.js

@@ -0,0 +1,37 @@
+import { computed } from "vue";
+import { useRuntimeConfig, useState } from "#imports";
+import {
+  DEFAULT_MONEY_CURRENCY,
+  DEFAULT_MONEY_LOCALE,
+  formatMoney,
+  formatMoneyParts
+} from "../utils/formatMoney.js";
+const STATE_KEY = "merkaly:money";
+export const useMoneyFormat = () => {
+  const state = useState(STATE_KEY, () => ({}));
+  const config = useRuntimeConfig().public.merkaly;
+  const currency = computed(() => state.value.currency || config?.money?.currency || DEFAULT_MONEY_CURRENCY);
+  const locale = computed(() => state.value.locale || config?.money?.locale || DEFAULT_MONEY_LOCALE);
+  const setMoneyDefaults2 = (defaults) => {
+    state.value = { ...state.value, ...defaults };
+  };
+  const resetMoneyDefaults = () => {
+    state.value = {};
+  };
+  const resolve = (options = {}) => ({
+    ...options,
+    currency: options.currency || currency.value,
+    locale: options.locale || locale.value,
+    symbolCurrency: options.symbolCurrency || currency.value
+  });
+  return {
+    currency,
+    format: (value, options) => formatMoney(value, resolve(options)),
+    formatParts: (value, options) => formatMoneyParts(value, resolve(options)),
+    locale,
+    resetMoneyDefaults,
+    resolve,
+    setMoneyDefaults: setMoneyDefaults2
+  };
+};
+export const setMoneyDefaults = (defaults) => useMoneyFormat().setMoneyDefaults(defaults);

package/dist/runtime/utils/formatMoney.d.ts

@@ -1,19 +1,49 @@
+export declare const DEFAULT_MONEY_CURRENCY = "USD";
+export declare const DEFAULT_MONEY_LOCALE = "en-US";
 export interface FormatMoneyOptions {
     base?: number;
+    /**
+     * ISO 4217 code (`BRL`, `USD`, ...). For backward compatibility a plain symbol
+     * (`$`, `R$`) is also accepted: the number is formatted with `symbolCurrency`
+     * (or USD) and the symbol replaces the currency sign.
+     */
     currency?: string;
     locale?: string;
     mode?: Intl.NumberFormatOptionsStyle;
     notation?: Intl.NumberFormatOptions['notation'];
     maximumFractionDigits?: number;
+    /** Currency used for the number layout when `currency` is a symbol. */
+    symbolCurrency?: string;
 }
+export interface FormatMoneyParts {
+    /** Everything before the integer part (sign, currency symbol, spacing). */
+    prefix: string;
+    /** Integer part with grouping separators. */
+    amount: string;
+    /** Decimal separator plus fraction digits (empty when there are none). */
+    digits: string;
+    /** Everything after the fraction (suffix currency symbols, compact units). */
+    suffix: string;
+}
+export declare function isCurrencyCode(value?: string): value is string;
+/**
+ * Splits a monetary value held as integer cents into display parts using
+ * `Intl.NumberFormat#formatToParts`, so multi-character symbols (`R$`) and
+ * locale separators (`249,69`) are preserved.
+ */
+export declare function formatMoneyParts(value: number, options?: FormatMoneyOptions): FormatMoneyParts;
 /**
  * Formats a monetary value held as an **integer in the minor unit (cents)**.
  *
  * Across Merkaly money is stored and transported as integer cents ($1.00 -> 100),
  * so this helper divides by `base` (default 100) before formatting. Pass cents in,
- * get a currency string out: `formatMoney(100)` -> `"$1.00"`.
+ * get a currency string out: `formatMoney(100)` -> `"$1.00"`,
+ * `formatMoney(24969, { currency: 'BRL', locale: 'pt-BR' })` -> `"R$ 249,69"`.
+ *
+ * This helper is pure (no app defaults). Inside components prefer
+ * `useMoneyFormat().format()`, which applies the app-level currency/locale.
  *
  * For non-currency numbers (counts, units, percentages) use `formatNumber` /
- * `MKFormatNumber` instead — those do NOT divide and would show the raw cents.
+ * `MKFormatNumber` instead, those do NOT divide and would show the raw cents.
  */
 export declare function formatMoney(value: number, options?: FormatMoneyOptions): string;

package/dist/runtime/utils/formatMoney.js

@@ -1,8 +1,45 @@
-export function formatMoney(value, options = {}) {
-  return (value / (options.base ?? 100)).toLocaleString(options.locale ?? "en-US", {
-    style: options.mode ?? "currency",
-    currency: options.currency ?? "USD",
+export const DEFAULT_MONEY_CURRENCY = "USD";
+export const DEFAULT_MONEY_LOCALE = "en-US";
+const CURRENCY_CODE = /^[A-Z]{3}$/i;
+export function isCurrencyCode(value) {
+  return Boolean(value && CURRENCY_CODE.test(value));
+}
+function toFormatter(options) {
+  const symbol = isCurrencyCode(options.currency) ? void 0 : options.currency;
+  const currency = symbol ? isCurrencyCode(options.symbolCurrency) ? options.symbolCurrency : DEFAULT_MONEY_CURRENCY : options.currency ?? DEFAULT_MONEY_CURRENCY;
+  const formatter = new Intl.NumberFormat(options.locale || DEFAULT_MONEY_LOCALE, {
+    currency: currency.toUpperCase(),
+    maximumFractionDigits: options.maximumFractionDigits,
     notation: options.notation,
-    maximumFractionDigits: options.maximumFractionDigits
+    style: options.mode ?? "currency"
+  });
+  return { formatter, symbol };
+}
+export function formatMoneyParts(value, options = {}) {
+  const { formatter, symbol } = toFormatter(options);
+  const parts = formatter.formatToParts(value / (options.base ?? 100)).map((part) => symbol && part.type === "currency" ? { ...part, value: symbol } : part);
+  const result = { prefix: "", amount: "", digits: "", suffix: "" };
+  const firstNumeric = parts.findIndex((part) => part.type === "integer");
+  let lastNumeric = -1;
+  parts.forEach((part, index) => {
+    if (["integer", "group", "decimal", "fraction"].includes(part.type)) {
+      lastNumeric = index;
+    }
   });
+  parts.forEach((part, index) => {
+    if (firstNumeric === -1 || index < firstNumeric) {
+      result.prefix += part.value;
+    } else if (index > lastNumeric) {
+      result.suffix += part.value;
+    } else if (part.type === "decimal" || part.type === "fraction") {
+      result.digits += part.value;
+    } else {
+      result.amount += part.value;
+    }
+  });
+  return result;
+}
+export function formatMoney(value, options = {}) {
+  const parts = formatMoneyParts(value, options);
+  return parts.prefix + parts.amount + parts.digits + parts.suffix;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merkaly/nuxt",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/merkaly-io/nuxt.git"
@@ -30,7 +30,7 @@
   "dependencies": {
     "@auth0/auth0-spa-js": "^2.29.0",
     "@bootstrap-vue-next/nuxt": "^1.0.0",
-    "@nuxt/devtools": "^3.4.0",
+    "@nuxt/devtools": "^4.0.0",
     "@nuxt/eslint": "1.17.0",
     "@nuxt/eslint-config": "^1.17.0",
     "@nuxt/fonts": "1.2.0",