@tsi-developpement/tsi-shared-ui 1.9.13 → 1.10.0

package/esm2022/lib/functions/currency-state.functions.mjs

@@ -0,0 +1,203 @@
+/**
+ * Internal currency-state resolution shared by the four currency components
+ * (Tsi-Currency-Other-Input/Display, Tsi-Currency-Societe-Input/Display).
+ *
+ * This module is intentionally NOT re-exported from `functions/index.ts`, so it
+ * is an internal implementation detail and not part of the library public API.
+ *
+ * A currency "state" combines two independent checks:
+ *  1. Is the currency code a recognized ISO-4217 code?
+ *  2. Does the value carry more decimal places than the currency supports?
+ * The result drives a two-tier visual state in the components:
+ *  - `error`   → invalid/missing code, or (inputs) a value that exceeds the
+ *                currency's decimals and therefore cannot be safely edited;
+ *  - `warning` → (displays) a value that exceeds the currency's decimals, shown
+ *                raw so no precision is hidden.
+ */
+/**
+ * i18n keys resolved by the host app's `LocalizePipe`. Centralized here so the
+ * components and the backend translation files (FR/EN/AR) stay in sync.
+ */
+export const CurrencyStateKeys = {
+    noCurrencySupplied: 'sharedUi-currency-error-noCurrencySupplied',
+    invalidCurrencySupplied: 'sharedUi-currency-error-invalidCurrencySupplied',
+    valueExceedsDecimalsError: 'sharedUi-currency-error-valueExceedsDecimals',
+    valueExceedsDecimalsWarning: 'sharedUi-currency-warning-valueExceedsDecimals',
+};
+/**
+ * Placeholders replaced when building a message, so the currency and the decimal
+ * figures are named inline. Translations must include the tokens they need
+ * (see the FR/EN/AR translation files):
+ *  - `{devise}`   → the currency code
+ *  - `{decimals}` → the value's decimal-place count (mismatch messages only)
+ *  - `{allowed}`  → the decimals the currency allows (mismatch messages only)
+ */
+export const CurrencyPlaceholder = '{devise}';
+export const ValueDecimalsPlaceholder = '{decimals}';
+export const AllowedDecimalsPlaceholder = '{allowed}';
+/**
+ * English fallbacks used when a translation key is missing, so a raw key slug is
+ * never displayed to the user. Currency-referencing messages embed the
+ * placeholders above.
+ */
+const Fallbacks = {
+    [CurrencyStateKeys.noCurrencySupplied]: 'No currency provided',
+    [CurrencyStateKeys.invalidCurrencySupplied]: `Unrecognized currency: ${CurrencyPlaceholder}`,
+    [CurrencyStateKeys.valueExceedsDecimalsError]: `This amount has ${ValueDecimalsPlaceholder} decimals but the ${CurrencyPlaceholder} currency allows only ${AllowedDecimalsPlaceholder} — it cannot be edited`,
+    [CurrencyStateKeys.valueExceedsDecimalsWarning]: `This amount has ${ValueDecimalsPlaceholder} decimals but the ${CurrencyPlaceholder} currency allows only ${AllowedDecimalsPlaceholder}`,
+};
+const WELL_FORMED_CODE = /^[A-Z]{3}$/;
+/**
+ * Memoized set of ISO-4217 codes the runtime recognizes, via
+ * `Intl.supportedValuesOf('currency')`. Returns `null` on runtimes that do not
+ * support the API, so callers can fall back to a well-formedness check.
+ */
+let _supportedCurrencies;
+function getSupportedCurrencies() {
+    if (_supportedCurrencies !== undefined) {
+        return _supportedCurrencies;
+    }
+    const intl = Intl;
+    if (typeof intl.supportedValuesOf === 'function') {
+        try {
+            _supportedCurrencies = new Set(intl.supportedValuesOf('currency'));
+        }
+        catch {
+            _supportedCurrencies = null;
+        }
+    }
+    else {
+        _supportedCurrencies = null;
+    }
+    return _supportedCurrencies;
+}
+/**
+ * Returns `true` when `code` is a recognized ISO-4217 currency code.
+ *
+ * Prefers the exact `Intl.supportedValuesOf('currency')` list; on older runtimes
+ * falls back to a 3-letter well-formedness check plus `Intl.NumberFormat`.
+ * Case-insensitive (the code is upper-cased before checking).
+ */
+export function isValidCurrency(code) {
+    if (!code) {
+        return false;
+    }
+    const normalized = code.toUpperCase();
+    const supported = getSupportedCurrencies();
+    if (supported) {
+        return supported.has(normalized);
+    }
+    if (!WELL_FORMED_CODE.test(normalized)) {
+        return false;
+    }
+    try {
+        // eslint-disable-next-line no-new
+        new Intl.NumberFormat('en', { style: 'currency', currency: normalized });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Number of fraction digits the given currency supports (ISO/locale default). */
+function getCurrencyDecimals(code, locale) {
+    try {
+        return new Intl.NumberFormat(locale, { style: 'currency', currency: code })
+            .resolvedOptions().maximumFractionDigits ?? 2;
+    }
+    catch {
+        return 2;
+    }
+}
+/**
+ * Counts the number of decimal places carried by a finite number, using its
+ * shortest round-trip string representation (handles exponential notation).
+ */
+function countDecimals(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    const str = Math.abs(value).toString();
+    if (str.indexOf('e-') !== -1) {
+        const [mantissa, exponent] = str.split('e-');
+        const mantissaDecimals = mantissa.includes('.') ? mantissa.split('.')[1].length : 0;
+        return mantissaDecimals + Number(exponent);
+    }
+    const dotIndex = str.indexOf('.');
+    return dotIndex === -1 ? 0 : str.length - dotIndex - 1;
+}
+/**
+ * Resolves the display state for a (currency code, value) pair.
+ *
+ * @param code             ISO-4217 currency code supplied to the component.
+ * @param value            the monetary value being shown/edited.
+ * @param locale           locale used to derive the currency's fraction digits.
+ * @param mismatchSeverity severity applied when the value exceeds the currency's
+ *                         decimals: `'error'` for inputs (renders read-only),
+ *                         `'warning'` for displays (renders the raw value).
+ */
+export function resolveCurrencyState(code, value, locale, mismatchSeverity) {
+    if (!code) {
+        return {
+            severity: 'error',
+            isValid: false,
+            tooltipKey: CurrencyStateKeys.noCurrencySupplied,
+            isoDecimals: -1,
+        };
+    }
+    const normalized = code.toUpperCase();
+    if (!isValidCurrency(normalized)) {
+        return {
+            severity: 'error',
+            isValid: false,
+            tooltipKey: CurrencyStateKeys.invalidCurrencySupplied,
+            isoDecimals: -1,
+            currencyCode: normalized,
+        };
+    }
+    const isoDecimals = getCurrencyDecimals(normalized, locale);
+    if (value != null && Number.isFinite(value)) {
+        const valueDecimals = countDecimals(value);
+        if (valueDecimals > isoDecimals) {
+            return {
+                severity: mismatchSeverity,
+                isValid: true,
+                tooltipKey: mismatchSeverity === 'warning'
+                    ? CurrencyStateKeys.valueExceedsDecimalsWarning
+                    : CurrencyStateKeys.valueExceedsDecimalsError,
+                isoDecimals,
+                valueDecimals,
+                currencyCode: normalized,
+            };
+        }
+    }
+    return {
+        severity: 'ok',
+        isValid: true,
+        tooltipKey: '',
+        isoDecimals,
+        currencyCode: normalized,
+    };
+}
+/**
+ * Builds the tooltip message for a resolved state using the supplied `translate`
+ * callback (typically `LocalizePipe.transform`). Falls back to a built-in
+ * English message when the key resolves to itself (missing translation), so a
+ * raw key slug is never shown. Any {@link CurrencyPlaceholder} token in the
+ * message is replaced with the currency code, so the offending currency is named
+ * inline.
+ */
+export function localizeCurrencyState(state, translate) {
+    if (state.severity === 'ok' || !state.tooltipKey) {
+        return '';
+    }
+    const translated = translate(state.tooltipKey);
+    const message = !translated || translated === state.tooltipKey
+        ? (Fallbacks[state.tooltipKey] ?? '')
+        : translated;
+    return message
+        .split(CurrencyPlaceholder).join(state.currencyCode ?? '')
+        .split(ValueDecimalsPlaceholder).join(state.valueDecimals != null ? String(state.valueDecimals) : '')
+        .split(AllowedDecimalsPlaceholder).join(state.isoDecimals >= 0 ? String(state.isoDecimals) : '');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency-state.functions.js","sourceRoot":"","sources":["../../../../../projects/tsi-shared-ui/src/lib/functions/currency-state.functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,kBAAkB,EAAE,4CAA4C;IAChE,uBAAuB,EAAE,iDAAiD;IAC1E,yBAAyB,EAAE,8CAA8C;IACzE,2BAA2B,EAAE,gDAAgD;CACrE,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;AAC9C,MAAM,CAAC,MAAM,wBAAwB,GAAG,YAAY,CAAC;AACrD,MAAM,CAAC,MAAM,0BAA0B,GAAG,WAAW,CAAC;AAEtD;;;;GAIG;AACH,MAAM,SAAS,GAA2B;IACxC,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,EAAE,sBAAsB;IAC9D,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,EAAE,0BAA0B,mBAAmB,EAAE;IAC5F,CAAC,iBAAiB,CAAC,yBAAyB,CAAC,EAC3C,mBAAmB,wBAAwB,qBAAqB,mBAAmB,yBAAyB,0BAA0B,wBAAwB;IAChK,CAAC,iBAAiB,CAAC,2BAA2B,CAAC,EAC7C,mBAAmB,wBAAwB,qBAAqB,mBAAmB,yBAAyB,0BAA0B,EAAE;CAC3I,CAAC;AAmBF,MAAM,gBAAgB,GAAG,YAAY,CAAC;AAEtC;;;;GAIG;AACH,IAAI,oBAAoD,CAAC;AACzD,SAAS,sBAAsB;IAC7B,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;QACvC,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IACD,MAAM,IAAI,GAAG,IAAoE,CAAC;IAClF,IAAI,OAAO,IAAI,CAAC,iBAAiB,KAAK,UAAU,EAAE,CAAC;QACjD,IAAI,CAAC;YACH,oBAAoB,GAAG,IAAI,GAAG,CAAS,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAC;QAC7E,CAAC;QAAC,MAAM,CAAC;YACP,oBAAoB,GAAG,IAAI,CAAC;QAC9B,CAAC;IACH,CAAC;SAAM,CAAC;QACN,oBAAoB,GAAG,IAAI,CAAC;IAC9B,CAAC;IACD,OAAO,oBAAoB,CAAC;AAC9B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,IAAa;IAC3C,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAEtC,MAAM,SAAS,GAAG,sBAAsB,EAAE,CAAC;IAC3C,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QACvC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC;QACH,kCAAkC;QAClC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;QACzE,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,kFAAkF;AAClF,SAAS,mBAAmB,CAAC,IAAY,EAAE,MAAc;IACvD,IAAI,CAAC;QACH,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;aACxE,eAAe,EAAE,CAAC,qBAAqB,IAAI,CAAC,CAAC;IAClD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,CAAC;IACX,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,KAAa;IAClC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,CAAC,CAAC;IACX,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;IACvC,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAC7B,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACpF,OAAO,gBAAgB,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;IACD,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,OAAO,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,QAAQ,GAAG,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAwB,EACxB,KAAgC,EAChC,MAAc,EACd,gBAAqC;IAErC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO;YACL,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,KAAK;YACd,UAAU,EAAE,iBAAiB,CAAC,kBAAkB;YAChD,WAAW,EAAE,CAAC,CAAC;SAChB,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACtC,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,CAAC;QACjC,OAAO;YACL,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,KAAK;YACd,UAAU,EAAE,iBAAiB,CAAC,uBAAuB;YACrD,WAAW,EAAE,CAAC,CAAC;YACf,YAAY,EAAE,UAAU;SACzB,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,mBAAmB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC5D,IAAI,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5C,MAAM,aAAa,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,aAAa,GAAG,WAAW,EAAE,CAAC;YAChC,OAAO;gBACL,QAAQ,EAAE,gBAAgB;gBAC1B,OAAO,EAAE,IAAI;gBACb,UAAU,EAAE,gBAAgB,KAAK,SAAS;oBACxC,CAAC,CAAC,iBAAiB,CAAC,2BAA2B;oBAC/C,CAAC,CAAC,iBAAiB,CAAC,yBAAyB;gBAC/C,WAAW;gBACX,aAAa;gBACb,YAAY,EAAE,UAAU;aACzB,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,IAAI;QACd,OAAO,EAAE,IAAI;QACb,UAAU,EAAE,EAAE;QACd,WAAW;QACX,YAAY,EAAE,UAAU;KACzB,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAoB,EACpB,SAAkC;IAElC,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;QACjD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,UAAU,GAAG,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAC/C,MAAM,OAAO,GAAG,CAAC,UAAU,IAAI,UAAU,KAAK,KAAK,CAAC,UAAU;QAC5D,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACrC,CAAC,CAAC,UAAU,CAAC;IAEf,OAAO,OAAO;SACX,KAAK,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC;SACzD,KAAK,CAAC,wBAAwB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SACpG,KAAK,CAAC,0BAA0B,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AACrG,CAAC","sourcesContent":["/**\r\n * Internal currency-state resolution shared by the four currency components\r\n * (Tsi-Currency-Other-Input/Display, Tsi-Currency-Societe-Input/Display).\r\n *\r\n * This module is intentionally NOT re-exported from `functions/index.ts`, so it\r\n * is an internal implementation detail and not part of the library public API.\r\n *\r\n * A currency \"state\" combines two independent checks:\r\n *  1. Is the currency code a recognized ISO-4217 code?\r\n *  2. Does the value carry more decimal places than the currency supports?\r\n * The result drives a two-tier visual state in the components:\r\n *  - `error`   → invalid/missing code, or (inputs) a value that exceeds the\r\n *                currency's decimals and therefore cannot be safely edited;\r\n *  - `warning` → (displays) a value that exceeds the currency's decimals, shown\r\n *                raw so no precision is hidden.\r\n */\r\n\r\n/**\r\n * i18n keys resolved by the host app's `LocalizePipe`. Centralized here so the\r\n * components and the backend translation files (FR/EN/AR) stay in sync.\r\n */\r\nexport const CurrencyStateKeys = {\r\n  noCurrencySupplied: 'sharedUi-currency-error-noCurrencySupplied',\r\n  invalidCurrencySupplied: 'sharedUi-currency-error-invalidCurrencySupplied',\r\n  valueExceedsDecimalsError: 'sharedUi-currency-error-valueExceedsDecimals',\r\n  valueExceedsDecimalsWarning: 'sharedUi-currency-warning-valueExceedsDecimals',\r\n} as const;\r\n\r\n/**\r\n * Placeholders replaced when building a message, so the currency and the decimal\r\n * figures are named inline. Translations must include the tokens they need\r\n * (see the FR/EN/AR translation files):\r\n *  - `{devise}`   → the currency code\r\n *  - `{decimals}` → the value's decimal-place count (mismatch messages only)\r\n *  - `{allowed}`  → the decimals the currency allows (mismatch messages only)\r\n */\r\nexport const CurrencyPlaceholder = '{devise}';\r\nexport const ValueDecimalsPlaceholder = '{decimals}';\r\nexport const AllowedDecimalsPlaceholder = '{allowed}';\r\n\r\n/**\r\n * English fallbacks used when a translation key is missing, so a raw key slug is\r\n * never displayed to the user. Currency-referencing messages embed the\r\n * placeholders above.\r\n */\r\nconst Fallbacks: Record<string, string> = {\r\n  [CurrencyStateKeys.noCurrencySupplied]: 'No currency provided',\r\n  [CurrencyStateKeys.invalidCurrencySupplied]: `Unrecognized currency: ${CurrencyPlaceholder}`,\r\n  [CurrencyStateKeys.valueExceedsDecimalsError]:\r\n    `This amount has ${ValueDecimalsPlaceholder} decimals but the ${CurrencyPlaceholder} currency allows only ${AllowedDecimalsPlaceholder} — it cannot be edited`,\r\n  [CurrencyStateKeys.valueExceedsDecimalsWarning]:\r\n    `This amount has ${ValueDecimalsPlaceholder} decimals but the ${CurrencyPlaceholder} currency allows only ${AllowedDecimalsPlaceholder}`,\r\n};\r\n\r\nexport type CurrencyStateSeverity = 'ok' | 'error' | 'warning';\r\n\r\nexport interface CurrencyState {\r\n  /** Overall severity of the current (code, value) pair. */\r\n  severity: CurrencyStateSeverity;\r\n  /** Whether the currency code itself is a recognized ISO-4217 code. */\r\n  isValid: boolean;\r\n  /** Translation key for the tooltip message (empty when severity === 'ok'). */\r\n  tooltipKey: string;\r\n  /** Fraction digits the currency supports (ISO/locale default); -1 if unknown. */\r\n  isoDecimals: number;\r\n  /** Decimal places the value carries; set only on a decimals mismatch. */\r\n  valueDecimals?: number;\r\n  /** Normalized (upper-cased) currency code, when one was supplied. */\r\n  currencyCode?: string;\r\n}\r\n\r\nconst WELL_FORMED_CODE = /^[A-Z]{3}$/;\r\n\r\n/**\r\n * Memoized set of ISO-4217 codes the runtime recognizes, via\r\n * `Intl.supportedValuesOf('currency')`. Returns `null` on runtimes that do not\r\n * support the API, so callers can fall back to a well-formedness check.\r\n */\r\nlet _supportedCurrencies: Set<string> | null | undefined;\r\nfunction getSupportedCurrencies(): Set<string> | null {\r\n  if (_supportedCurrencies !== undefined) {\r\n    return _supportedCurrencies;\r\n  }\r\n  const intl = Intl as unknown as { supportedValuesOf?: (key: string) => string[] };\r\n  if (typeof intl.supportedValuesOf === 'function') {\r\n    try {\r\n      _supportedCurrencies = new Set<string>(intl.supportedValuesOf('currency'));\r\n    } catch {\r\n      _supportedCurrencies = null;\r\n    }\r\n  } else {\r\n    _supportedCurrencies = null;\r\n  }\r\n  return _supportedCurrencies;\r\n}\r\n\r\n/**\r\n * Returns `true` when `code` is a recognized ISO-4217 currency code.\r\n *\r\n * Prefers the exact `Intl.supportedValuesOf('currency')` list; on older runtimes\r\n * falls back to a 3-letter well-formedness check plus `Intl.NumberFormat`.\r\n * Case-insensitive (the code is upper-cased before checking).\r\n */\r\nexport function isValidCurrency(code?: string): boolean {\r\n  if (!code) {\r\n    return false;\r\n  }\r\n  const normalized = code.toUpperCase();\r\n\r\n  const supported = getSupportedCurrencies();\r\n  if (supported) {\r\n    return supported.has(normalized);\r\n  }\r\n\r\n  if (!WELL_FORMED_CODE.test(normalized)) {\r\n    return false;\r\n  }\r\n  try {\r\n    // eslint-disable-next-line no-new\r\n    new Intl.NumberFormat('en', { style: 'currency', currency: normalized });\r\n    return true;\r\n  } catch {\r\n    return false;\r\n  }\r\n}\r\n\r\n/** Number of fraction digits the given currency supports (ISO/locale default). */\r\nfunction getCurrencyDecimals(code: string, locale: string): number {\r\n  try {\r\n    return new Intl.NumberFormat(locale, { style: 'currency', currency: code })\r\n      .resolvedOptions().maximumFractionDigits ?? 2;\r\n  } catch {\r\n    return 2;\r\n  }\r\n}\r\n\r\n/**\r\n * Counts the number of decimal places carried by a finite number, using its\r\n * shortest round-trip string representation (handles exponential notation).\r\n */\r\nfunction countDecimals(value: number): number {\r\n  if (!Number.isFinite(value)) {\r\n    return 0;\r\n  }\r\n  const str = Math.abs(value).toString();\r\n  if (str.indexOf('e-') !== -1) {\r\n    const [mantissa, exponent] = str.split('e-');\r\n    const mantissaDecimals = mantissa.includes('.') ? mantissa.split('.')[1].length : 0;\r\n    return mantissaDecimals + Number(exponent);\r\n  }\r\n  const dotIndex = str.indexOf('.');\r\n  return dotIndex === -1 ? 0 : str.length - dotIndex - 1;\r\n}\r\n\r\n/**\r\n * Resolves the display state for a (currency code, value) pair.\r\n *\r\n * @param code             ISO-4217 currency code supplied to the component.\r\n * @param value            the monetary value being shown/edited.\r\n * @param locale           locale used to derive the currency's fraction digits.\r\n * @param mismatchSeverity severity applied when the value exceeds the currency's\r\n *                         decimals: `'error'` for inputs (renders read-only),\r\n *                         `'warning'` for displays (renders the raw value).\r\n */\r\nexport function resolveCurrencyState(\r\n  code: string | undefined,\r\n  value: number | null | undefined,\r\n  locale: string,\r\n  mismatchSeverity: 'error' | 'warning'\r\n): CurrencyState {\r\n  if (!code) {\r\n    return {\r\n      severity: 'error',\r\n      isValid: false,\r\n      tooltipKey: CurrencyStateKeys.noCurrencySupplied,\r\n      isoDecimals: -1,\r\n    };\r\n  }\r\n\r\n  const normalized = code.toUpperCase();\r\n  if (!isValidCurrency(normalized)) {\r\n    return {\r\n      severity: 'error',\r\n      isValid: false,\r\n      tooltipKey: CurrencyStateKeys.invalidCurrencySupplied,\r\n      isoDecimals: -1,\r\n      currencyCode: normalized,\r\n    };\r\n  }\r\n\r\n  const isoDecimals = getCurrencyDecimals(normalized, locale);\r\n  if (value != null && Number.isFinite(value)) {\r\n    const valueDecimals = countDecimals(value);\r\n    if (valueDecimals > isoDecimals) {\r\n      return {\r\n        severity: mismatchSeverity,\r\n        isValid: true,\r\n        tooltipKey: mismatchSeverity === 'warning'\r\n          ? CurrencyStateKeys.valueExceedsDecimalsWarning\r\n          : CurrencyStateKeys.valueExceedsDecimalsError,\r\n        isoDecimals,\r\n        valueDecimals,\r\n        currencyCode: normalized,\r\n      };\r\n    }\r\n  }\r\n\r\n  return {\r\n    severity: 'ok',\r\n    isValid: true,\r\n    tooltipKey: '',\r\n    isoDecimals,\r\n    currencyCode: normalized,\r\n  };\r\n}\r\n\r\n/**\r\n * Builds the tooltip message for a resolved state using the supplied `translate`\r\n * callback (typically `LocalizePipe.transform`). Falls back to a built-in\r\n * English message when the key resolves to itself (missing translation), so a\r\n * raw key slug is never shown. Any {@link CurrencyPlaceholder} token in the\r\n * message is replaced with the currency code, so the offending currency is named\r\n * inline.\r\n */\r\nexport function localizeCurrencyState(\r\n  state: CurrencyState,\r\n  translate: (key: string) => string\r\n): string {\r\n  if (state.severity === 'ok' || !state.tooltipKey) {\r\n    return '';\r\n  }\r\n\r\n  const translated = translate(state.tooltipKey);\r\n  const message = !translated || translated === state.tooltipKey\r\n    ? (Fallbacks[state.tooltipKey] ?? '')\r\n    : translated;\r\n\r\n  return message\r\n    .split(CurrencyPlaceholder).join(state.currencyCode ?? '')\r\n    .split(ValueDecimalsPlaceholder).join(state.valueDecimals != null ? String(state.valueDecimals) : '')\r\n    .split(AllowedDecimalsPlaceholder).join(state.isoDecimals >= 0 ? String(state.isoDecimals) : '');\r\n}\r\n"]}

package/esm2022/lib/pipes/tsi-currency.pipe.mjs

@@ -1,29 +1,27 @@
-import { Pipe } from '@angular/core';
-import { locals } from '../consts/locals.const';
+import { CurrencyPipe } from '@angular/common';
+import { inject, Pipe } from '@angular/core';
+import { LocalizationService } from '../services/localization/localization.service';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
 export class TsiCurrencyPipe {
-    constructor(currencyPipe) {
-        this.currencyPipe = currencyPipe;
+    // Ctor
+    constructor() {
+        // Local props
+        this._display = 'symbol';
+        // DI
+        this._localizationService = inject(LocalizationService);
+        this._currencyPipe = inject(CurrencyPipe);
+        this._locale = this._localizationService.locale;
     }
-    transform(value, currencyCode, display = 'symbol', digitsInfo = '', locale = 'en-US') {
-        let formattedValue = this.currencyPipe.transform(value, currencyCode, display, digitsInfo, locale);
-        if (locale != locals.arabicLocal) {
-            return formattedValue;
-        }
-        if (!formattedValue)
-            return null;
-        const currencySymbol = formattedValue.match(/[^0-9,.]/g)?.join('') || '';
-        formattedValue = formattedValue.replace(currencySymbol, '');
-        return `${formattedValue} ${currencySymbol}`;
+    transform(value, currencyCode) {
+        return this._currencyPipe.transform(value, currencyCode, this._display, undefined, this._locale);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TsiCurrencyPipe, deps: [{ token: i1.CurrencyPipe }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TsiCurrencyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
     static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: TsiCurrencyPipe, name: "tsiCurrency" }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TsiCurrencyPipe, decorators: [{
             type: Pipe,
             args: [{
-                    name: 'tsiCurrency',
+                    name: 'tsiCurrency'
                 }]
-        }], ctorParameters: () => [{ type: i1.CurrencyPipe }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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