@rallycash/numbers 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @rallycash/numbers
+
+## 0.2.0
+
+### Minor Changes
+
+- 29af4c7: Add `@rallycash/numbers` with `NumberUtils` and `BigIntUtils` for shared number formatting and fixed-point bigint conversion.

package/README.md

@@ -1,3 +1,230 @@
-# Temporary Holding Version
+# `@rallycash/numbers`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared number formatting and fixed-point bigint conversion for Rally Cash apps.
+
+Two exports:
+
+```ts
+import { BigIntUtils, NumberUtils } from '@rallycash/numbers'
+```
+
+`NumberUtils` formats values for display. `BigIntUtils` converts and does integer arithmetic. USD and percentage scales are arguments, not constants in this package. Prisma is not a dependency. Pass any object with `toFixed(digits)` and `toNumber()`.
+
+## Install
+
+```bash
+yarn add @rallycash/numbers
+```
+
+## NumberUtils
+
+`formatNumber` is the general formatter. The named methods below are presets on top of it, except `formatUsd`, which always abbreviates.
+
+### `formatNumber(value, options?)`
+
+```ts
+formatNumber(
+  value: number | DecimalLike | null | undefined,
+  options?: FormatNumberOptions,
+): string
+```
+
+| Option | Default |
+| --- | --- |
+| `showExponents` | `true` |
+| `minSignificantDigits` | `4` |
+| `maxDecimals` | `6` |
+| `minDecimals` | `2` |
+| `abbrThreshold` | `10_000_000` |
+| `abbreviateLargeNumbers` | `true` |
+| `abbrMinSignificantDigits` | `3` |
+| `prefix` | `''` |
+
+`null`, `undefined`, and `NaN` return `''`. `0` returns `0.00` at the default fraction digits.
+
+```ts
+NumberUtils.formatNumber(1234.5) // "1,234.50"
+NumberUtils.formatNumber(1_000_000) // "1,000,000.00"
+NumberUtils.formatNumber(12_345_678) // "12.3M"
+NumberUtils.formatNumber(0.0000001234) // "0.0₆123"
+NumberUtils.formatNumber(null) // ""
+```
+
+Dust smaller than `maxDecimals` places, but not small enough for a subscript, renders as `0` plus `minDecimals` zeros. Values from 1 up to 10,000 use at most 2 fraction digits. Abbreviation starts at `abbrThreshold` when `abbreviateLargeNumbers` is true (10 million by default): `K`, `M`, `B`, `T`, `P`, `E`. An exact tier such as `1,000,000` uses that suffix, and a coefficient that rounds to `1,000` promotes to the next one.
+
+This is the server formatter. The web copy abbreviated from 1 trillion, used 4 fraction digits below 10, and rendered that underflow case as `0.00`.
+
+### Presets
+
+Each preset calls `formatNumber` with fixed options. Pass `options` to override the preset. `formatUsd` does not. It always abbreviates through `abbreviateNumber`.
+
+#### `formatCryptoBalance(value, options?)`
+
+Token amount. Same defaults as `formatNumber`, including subscripts for dust.
+
+```ts
+NumberUtils.formatCryptoBalance(1234.5) // "1,234.50"
+NumberUtils.formatCryptoBalance(0.0000001234) // "0.0₆123"
+```
+
+Atomic units go through `formatBigInt` or `BigIntUtils.toNumber` first. This method formats an already-human amount.
+
+#### `formatUsdBalance(value, options?)`
+
+Cash balance. Replaces `formatCurrencyAmount`.
+
+Preset options: `minDecimals: 2`, `maxDecimals: 2`, `minSignificantDigits: 0`, `showExponents: false`.
+
+The `$` is applied here, with the sign in front. `0`, `null`, `undefined`, and `NaN` return `$0.00`. Amounts at or above 10 million still abbreviate, same as `formatNumber`.
+
+```ts
+NumberUtils.formatUsdBalance(1234.5) // "$1,234.50"
+NumberUtils.formatUsdBalance(-1.2) // "-$1.20"
+NumberUtils.formatUsdBalance(0) // "$0.00"
+NumberUtils.formatUsdBalance(12_345_678) // "$12.3M"
+```
+
+#### `formatPercentage(value, options?)`
+
+Preset options: `minDecimals: 0`, `maxDecimals: 2`, `minSignificantDigits: 0`, `showExponents: false`.
+
+Does not append `%`.
+
+```ts
+NumberUtils.formatPercentage(12.3) // "12.3"
+NumberUtils.formatPercentage(12.345) // "12.35"
+NumberUtils.formatPercentage(0.0000001234) // "0"
+```
+
+#### `formatUsd(value)`
+
+Abbreviated USD. Not a `formatNumber` preset. Two fraction digits, trailing zeros kept, `$` in front.
+
+```ts
+NumberUtils.formatUsd(1.5) // "$1.50"
+NumberUtils.formatUsd(1234.5) // "$1.23K"
+NumberUtils.formatUsd(-12_345_678) // "-$12.35M"
+NumberUtils.formatUsd(null) // "$0.00"
+```
+
+`formatUsd(1234.5)` is `$1.23K`. `formatUsdBalance(1234.5)` is `$1,234.50`.
+
+#### `formatInteger(value, options?)`
+
+Whole numbers. Preset: `minDecimals: 0`, `maxDecimals: 0`, `minSignificantDigits: 0`, `showExponents: false`.
+
+```ts
+NumberUtils.formatInteger(6737233.2323223) // "6,737,233"
+```
+
+### Other NumberUtils methods
+
+| Method | Role |
+| --- | --- |
+| `formatTokenPrice(value)` | Alias of `formatNumber`. No extra preset. |
+| `formatBigInt(atomic, decimals, options?)` | Atomic `bigint`, integer string, or `DecimalLike` to a human string, then `formatNumber`. |
+| `abbreviateNumber(value, decimals = 2, preserveTrailingZeros = false)` | `K`/`M`/`B`/`T`/`P`/`E`. Negatives abbreviate. |
+| `formatLargeNumber(value)` | `abbreviateNumber(value, 2)`. |
+| `formatSwapAmount(value)` | Three significant digits after leading zeros. `0.000015045` becomes `0.0000150`. |
+| `expToString(value)` | Scientific notation to a plain decimal string. |
+| `computePercentile(sorted, percentile)` | Linear interpolation. Empty input returns `null`. |
+
+```ts
+NumberUtils.formatBigInt(1_500000n, 6) // "1.50"
+NumberUtils.formatSwapAmount(0.000015045814) // "0.0000150"
+NumberUtils.expToString(1e23) // "100000000000000000000000"
+```
+
+`formatBigInt` on a `DecimalLike` reads `toFixed(0)` and treats that as the atomic integer.
+
+## BigIntUtils
+
+```ts
+type BigIntInput = bigint | number | string | DecimalLike
+```
+
+A `bigint` passed to `toBigInt` is returned as-is. `decimals` applies to numbers, strings, and `DecimalLike`.
+
+### Conversion
+
+```ts
+BigIntUtils.toBigInt('1.5', 6) // 1500000n
+BigIntUtils.toBigInt(1e-7, 18) // 100000000000n
+BigIntUtils.toBigInt(5n, 6) // 5n
+BigIntUtils.toNumber(1_500000n, 6) // 1.5
+```
+
+`DecimalLike` uses `toFixed(decimals)`, then the same parser as a string. That keeps precision that `toNumber()` would lose.
+
+### Arithmetic
+
+`scale` on `multiplyByNumber` and `createPercentage` is the float-to-rational precision. Default `18` (server). Pass `10` for the web copy. It is not exported.
+
+```ts
+BigIntUtils.multiplyByNumber(1000n, 1.5) // 1500n
+BigIntUtils.multiplyByNumber(1000n, 0.5) // 500n
+BigIntUtils.multiplyByNumber(amount, multiplier, 10) // web scale
+
+BigIntUtils.createPercentage(10n, 100n) // 0.1
+BigIntUtils.createPercentage(0.0000000005, 0.0000000025) // 0.2
+
+BigIntUtils.abs(-3n)
+BigIntUtils.min(1n, 2n)
+BigIntUtils.max(1n, 2n)
+```
+
+When both `createPercentage` inputs are numbers, it divides them directly and ignores `scale`.
+
+`multiplyAsBigInt` and `usdToTokenAmount` take the decimal scale from the caller. There is no `USD_DECIMALS` export.
+
+```ts
+const USD_DECIMALS = 18 // app constant, not from this package
+
+BigIntUtils.multiplyAsBigInt(2, 3, 2) // 6
+BigIntUtils.usdToTokenAmount(5, 2, 6, USD_DECIMALS) // 2500000n
+BigIntUtils.usdToTokenAmount(5, 2500, 18, USD_DECIMALS) // 2000000000000000n
+BigIntUtils.usdToTokenAmount(0, 1, 6, USD_DECIMALS) // 0n
+```
+
+### Splitting
+
+From the web bigint helpers. Remainder lands on the last bucket. Totals are exact.
+
+```ts
+BigIntUtils.splitEvenly(100n, 3) // [33n, 33n, 34n]
+
+BigIntUtils.splitWithVariance(amount, count, 0.2, rng)
+// variance <= 0, count === 1, or amount === 0n falls back to splitEvenly
+
+BigIntUtils.clampToCaps([80n, 10n], [50n, 100n]) // [50n, 40n]
+```
+
+`splitEvenly` and `splitWithVariance` throw when `count <= 0`. `clampToCaps` throws when the caps are shorter than the amounts, or when the total cannot fit.
+
+## Types
+
+```ts
+type DecimalLike = {
+  toFixed(digits: number): string
+  toNumber(): number
+}
+
+type NumberInput = number | DecimalLike | null | undefined
+type UsdInput = NumberInput | string
+type BigIntInput = bigint | number | string | DecimalLike
+```
+
+Prisma's `Decimal` and decimal.js both satisfy `DecimalLike`. Detection is structural (`toFixed` and `toNumber`), not `instanceof`.
+
+## Names that moved
+
+| Wallet today | This package |
+| --- | --- |
+| `formatNumber` | `formatNumber` |
+| `formatCurrencyAmount` | `formatUsdBalance` (adds `$`, sign in front) |
+| `formatUSD` | `formatUsd` |
+| token balance via `formatNumber` | `formatCryptoBalance` |
+| `formatPercentage` | `formatPercentage` |
+| `formatInteger` | `formatInteger` |
+| `formatTokenPrice` | `formatTokenPrice` (still an alias of `formatNumber`) |
+| `USD_DECIMALS` / `PERCENTAGE_DECIMALS` | Not exported. Pass the scale in. |

package/dist/bigint-utils.d.ts

@@ -0,0 +1,17 @@
+import { type DecimalLike } from './decimal.js';
+export type BigIntInput = bigint | number | string | DecimalLike;
+export declare const BigIntUtils: {
+    multiplyByNumber: (value: bigint, multiplier: number, scale?: number) => bigint;
+    createPercentage: (numerator: BigIntInput, denominator: BigIntInput, scale?: number) => number;
+    abs: (value: bigint) => bigint;
+    min: (a: bigint, b: bigint) => bigint;
+    max: (a: bigint, b: bigint) => bigint;
+    toNumber: (value: BigIntInput, decimals?: number) => number;
+    toBigInt: (value: BigIntInput, decimals?: number) => bigint;
+    multiplyAsBigInt: (a: BigIntInput, b: BigIntInput, decimals: number) => number;
+    usdToTokenAmount: (usd: number, tokenPriceUsd: number, tokenDecimals: number, usdDecimals: number) => bigint;
+    splitEvenly: (amount: bigint, count: number) => bigint[];
+    splitWithVariance: (amount: bigint, count: number, variance: number, rng?: () => number) => bigint[];
+    clampToCaps: (initial: bigint[], caps: bigint[]) => bigint[];
+};
+//# sourceMappingURL=bigint-utils.d.ts.map

package/dist/bigint-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint-utils.d.ts","sourceRoot":"","sources":["../src/bigint-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,cAAc,CAAA;AAI9D,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAAA;AA4MhE,eAAO,MAAM,WAAW;8BAzLf,MAAM,cACD,MAAM;kCAaP,WAAW,eACT,WAAW;iBAcN,MAAM;aAEV,MAAM,KAAK,MAAM;aACjB,MAAM,KAAK,MAAM;sBApCR,WAAW,wBAAiB,MAAM;sBANlC,WAAW,wBAAiB,MAAM;0BA4C9B,WAAW,KAAK,WAAW,YAAY,MAAM;4BAQnE,MAAM,iBACI,MAAM,iBACN,MAAM,eACR,MAAM,KAClB,MAAM;0BA0BoB,MAAM,SAAS,MAAM,KAAG,MAAM,EAAE;gCA+BnD,MAAM,SACP,MAAM,YACH,MAAM,QACX,MAAM,MAAM,KAChB,MAAM,EAAE;2BA0CmB,MAAM,EAAE,QAAQ,MAAM,EAAE,KAAG,MAAM,EAAE;CAiDhE,CAAA"}

package/dist/bigint-utils.js

@@ -0,0 +1,178 @@
+import { isDecimalLike } from './decimal.js';
+import { expToString } from './number-utils.js';
+import { formatUnits, parseUnits } from './units.js';
+/**
+ * Float multipliers are turned into a rational at this scale.
+ * Server wallet code used 18. Web used 10. Pass `scale` to pick one.
+ * This is not a USD decimal count.
+ */
+const DEFAULT_FLOAT_SCALE = 18;
+const toBigInt = (value, decimals = 0) => {
+    if (typeof value === 'bigint')
+        return value;
+    if (isDecimalLike(value))
+        return parseUnits(value.toFixed(decimals), decimals);
+    return parseUnits(expToString(value), decimals);
+};
+const toNumber = (value, decimals = 0) => Number(formatUnits(toBigInt(value), decimals));
+const multiplyByNumber = (value, multiplier, scale = DEFAULT_FLOAT_SCALE) => {
+    if (!Number.isFinite(multiplier) || multiplier === 0)
+        return 0n;
+    const factor = 10 ** scale;
+    const numerator = multiplier < 1 ? 1n * BigInt(factor) : toBigInt(multiplier * factor);
+    const denominator = multiplier < 1 ? toBigInt((1 / multiplier) * factor) : 1n * BigInt(factor);
+    return (value * numerator) / denominator;
+};
+const createPercentage = (numerator, denominator, scale = DEFAULT_FLOAT_SCALE) => {
+    if (typeof numerator === 'number' && typeof denominator === 'number') {
+        return numerator / denominator;
+    }
+    return Number(formatUnits((toBigInt(numerator) * BigInt(10 ** scale)) / toBigInt(denominator), scale));
+};
+const abs = (value) => (value < 0n ? -value : value);
+const min = (a, b) => (a < b ? a : b);
+const max = (a, b) => (a > b ? a : b);
+const multiplyAsBigInt = (a, b, decimals) => toNumber(toBigInt(a, decimals) * toBigInt(b, decimals), decimals * 2);
+/**
+ * USD notional to token atomic units at `tokenPriceUsd`.
+ * `usdDecimals` is the caller's USD scale. This package does not pick one.
+ */
+const usdToTokenAmount = (usd, tokenPriceUsd, tokenDecimals, usdDecimals) => {
+    if (!(usd > 0) ||
+        !(tokenPriceUsd > 0) ||
+        tokenDecimals < 0 ||
+        usdDecimals < 0)
+        return 0n;
+    return ((toBigInt(usd, usdDecimals) * 10n ** BigInt(tokenDecimals)) /
+        toBigInt(tokenPriceUsd, usdDecimals));
+};
+/**
+ * Split a bigint amount into `count` parts as evenly as possible.
+ * Any remainder is distributed starting from the last bucket, so that
+ * `buckets[count - 1]` absorbs the remainder bits.
+ *
+ * Guarantees:
+ * - buckets.length === count
+ * - buckets.reduce(+, 0n) === amount
+ * - every bucket >= 0n
+ *
+ * Throws when count <= 0.
+ */
+const splitEvenly = (amount, count) => {
+    if (count <= 0)
+        throw new Error('splitEvenly: count must be > 0');
+    if (count === 1)
+        return [amount];
+    const base = amount / BigInt(count);
+    const remainder = amount - base * BigInt(count);
+    const buckets = Array.from({ length: count }, () => base);
+    const last = buckets[count - 1];
+    if (last === undefined)
+        throw new Error('splitEvenly: missing bucket');
+    buckets[count - 1] = last + remainder;
+    return buckets;
+};
+/**
+ * Like `splitEvenly`, but each of the first N-1 buckets is jittered within
+ * ±`variance` (as a fraction of the even-split base, e.g. 0.2 = ±20%),
+ * and the last bucket absorbs whatever's left so the total is preserved
+ * exactly.
+ *
+ * - Returns `splitEvenly` when `variance <= 0`, `count === 1`, or `amount === 0n`.
+ * - The last bucket's variance is emergent (it absorbs the complement of
+ *   the first N-1 jitters). If those buckets already sum past `amount`,
+ *   the excess is taken back from them so the total stays exact and no
+ *   bucket goes negative. Callers that need a strict per-bucket cap should
+ *   compose with `clampToCaps`.
+ *
+ * Guarantees (same as splitEvenly):
+ * - buckets.length === count
+ * - buckets.reduce(+, 0n) === amount
+ * - every bucket >= 0n (when variance ≤ 1; throws otherwise on negative)
+ */
+const splitWithVariance = (amount, count, variance, rng = Math.random) => {
+    if (count <= 0)
+        throw new Error('splitWithVariance: count must be > 0');
+    if (count === 1 || variance <= 0 || amount === 0n) {
+        return splitEvenly(amount, count);
+    }
+    const clampedVariance = Math.min(1, Math.max(0, variance));
+    const precision = 1000000n;
+    const base = amount / BigInt(count);
+    const buckets = [];
+    let assigned = 0n;
+    for (let i = 0; i < count - 1; i++) {
+        const factor = 1 + (rng() * 2 - 1) * clampedVariance;
+        const scaled = BigInt(Math.round(factor * Number(precision)));
+        const bucket = (base * scaled) / precision;
+        const nonNegative = bucket < 0n ? 0n : bucket;
+        buckets.push(nonNegative);
+        assigned += nonNegative;
+    }
+    let remaining = amount - assigned;
+    if (remaining < 0n) {
+        for (let i = buckets.length - 1; i >= 0 && remaining < 0n; i--) {
+            const bucket = buckets[i] ?? 0n;
+            const deficit = -remaining;
+            const take = bucket < deficit ? bucket : deficit;
+            buckets[i] = bucket - take;
+            remaining += take;
+        }
+    }
+    buckets.push(remaining < 0n ? 0n : remaining);
+    return buckets;
+};
+/**
+ * Given an initial per-bucket allocation and per-bucket caps, clamp each
+ * bucket to its cap and redistribute the overflow to buckets that still
+ * have headroom (largest-headroom-first), preserving the total sum.
+ *
+ * Throws if `sum(caps) < sum(initial)`.
+ */
+const clampToCaps = (initial, caps) => {
+    if (initial.length !== caps.length) {
+        throw new Error('clampToCaps: initial and caps must be the same length');
+    }
+    const total = initial.reduce((sum, amount) => sum + amount, 0n);
+    const totalCap = caps.reduce((sum, cap) => sum + cap, 0n);
+    if (total > totalCap) {
+        throw new Error('clampToCaps: total exceeds aggregate capacity');
+    }
+    const result = initial.map((amount, i) => {
+        const cap = caps[i] ?? 0n;
+        return amount > cap ? cap : amount;
+    });
+    let shortfall = total - result.reduce((sum, amount) => sum + amount, 0n);
+    if (shortfall === 0n)
+        return result;
+    const byHeadroomDesc = result
+        .map((_, i) => i)
+        .sort((a, b) => {
+        const headroomA = (caps[a] ?? 0n) - (result[a] ?? 0n);
+        const headroomB = (caps[b] ?? 0n) - (result[b] ?? 0n);
+        return headroomA > headroomB ? -1 : headroomA < headroomB ? 1 : 0;
+    });
+    for (const i of byHeadroomDesc) {
+        if (shortfall === 0n)
+            break;
+        const headroom = (caps[i] ?? 0n) - (result[i] ?? 0n);
+        const give = shortfall < headroom ? shortfall : headroom;
+        result[i] = (result[i] ?? 0n) + give;
+        shortfall -= give;
+    }
+    return result;
+};
+export const BigIntUtils = {
+    multiplyByNumber,
+    createPercentage,
+    abs,
+    min,
+    max,
+    toNumber,
+    toBigInt,
+    multiplyAsBigInt,
+    usdToTokenAmount,
+    splitEvenly,
+    splitWithVariance,
+    clampToCaps,
+};

package/dist/decimal.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Structural stand-in for Prisma's `Decimal` and decimal.js.
+ * Both satisfy this: `toFixed` keeps the decimal string, `toNumber` is the float view.
+ */
+export type DecimalLike = {
+    toFixed(digits: number): string;
+    toNumber(): number;
+};
+export type NumberInput = number | DecimalLike | null | undefined;
+export declare function isDecimalLike(value: unknown): value is DecimalLike;
+export declare function coerceNumber(value: NumberInput): number | null | undefined;
+//# sourceMappingURL=decimal.d.ts.map

package/dist/decimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../src/decimal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IAC/B,QAAQ,IAAI,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,CAAA;AAEjE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAMlE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAK1E"}

package/dist/decimal.js

@@ -0,0 +1,16 @@
+export function isDecimalLike(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (!('toFixed' in value) || !('toNumber' in value))
+        return false;
+    return (typeof value.toFixed === 'function' && typeof value.toNumber === 'function');
+}
+export function coerceNumber(value) {
+    if (value == null)
+        return value;
+    if (typeof value === 'number')
+        return value;
+    if (isDecimalLike(value))
+        return value.toNumber();
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { type BigIntInput, BigIntUtils } from './bigint-utils.js';
+export type { DecimalLike, NumberInput } from './decimal.js';
+export { type FormatNumberOptions, NumberUtils, type UsdInput, } from './number-utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACjE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EACL,KAAK,mBAAmB,EACxB,WAAW,EACX,KAAK,QAAQ,GACd,MAAM,mBAAmB,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { BigIntUtils } from './bigint-utils.js';
+export { NumberUtils, } from './number-utils.js';

package/dist/number-utils.d.ts

@@ -0,0 +1,31 @@
+import { type DecimalLike, type NumberInput } from './decimal.js';
+export type FormatNumberOptions = {
+    showExponents?: boolean;
+    minSignificantDigits?: number;
+    maxDecimals?: number;
+    minDecimals?: number;
+    abbrThreshold?: number;
+    prefix?: string;
+    abbreviateLargeNumbers?: boolean;
+    abbrMinSignificantDigits?: number;
+};
+export type UsdInput = NumberInput | string;
+export declare const expToString: (value: string | number) => string;
+declare function computePercentile(sorted: number[], percentile: number): number | null;
+export declare const NumberUtils: {
+    formatNumber: (value: NumberInput, { showExponents, minSignificantDigits, maxDecimals: maxDecimalsParam, minDecimals: minDecimalsParam, abbrThreshold, abbreviateLargeNumbers, abbrMinSignificantDigits, prefix, }?: FormatNumberOptions) => string;
+    formatCryptoBalance: (value: NumberInput, options?: FormatNumberOptions) => string;
+    formatUsdBalance: (value: UsdInput, options?: FormatNumberOptions) => string;
+    formatPercentage: (value: NumberInput, options?: FormatNumberOptions) => string;
+    formatUsd: (value: UsdInput) => string;
+    formatInteger: (value: NumberInput, options?: FormatNumberOptions) => string;
+    formatTokenPrice: (price: NumberInput) => string;
+    formatBigInt: (input: bigint | string | DecimalLike, decimals: number, formatOptions?: FormatNumberOptions) => string;
+    abbreviateNumber: (num: number, decimals?: number, preserveTrailingZeros?: boolean) => string;
+    formatLargeNumber: (value: number | DecimalLike) => string;
+    formatSwapAmount: (value: number | string) => string;
+    expToString: (value: string | number) => string;
+    computePercentile: typeof computePercentile;
+};
+export {};
+//# sourceMappingURL=number-utils.d.ts.map

package/dist/number-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-utils.d.ts","sourceRoot":"","sources":["../src/number-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/E,MAAM,MAAM,mBAAmB,GAAG;IAChC,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,wBAAwB,CAAC,EAAE,MAAM,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,WAAW,GAAG,MAAM,CAAA;AAE3C,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,GAAG,MAAM,KAAG,MAMpD,CAAA;AAwVD,iBAAS,iBAAiB,CACxB,MAAM,EAAE,MAAM,EAAE,EAChB,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,IAAI,CAYf;AAED,eAAO,MAAM,WAAW;0BArPf,WAAW,oLAUf,mBAAmB;iCAuKf,WAAW,YACR,mBAAmB;8BAPE,QAAQ,YAAY,mBAAmB;8BAUvC,WAAW,YAAY,mBAAmB;uBAbjD,QAAQ;2BAgBJ,WAAW,YAAY,mBAAmB;8BAGvC,WAAW;0BAGnC,MAAM,GAAG,MAAM,GAAG,WAAW,YAC1B,MAAM,kBACA,mBAAmB;4BAjP9B,MAAM;+BA8PqB,MAAM,GAAG,WAAW;8BAKrB,MAAM,GAAG,MAAM,KAAG,MAAM;yBA5UtB,MAAM,GAAG,MAAM,KAAG,MAAM;;CA6X1D,CAAA"}