@c9up/atom 0.1.5 → 0.1.8

package/README.md

@@ -1,29 +1,79 @@
 # @c9up/atom
 
-> Exact decimal arithmetic + statistics for the Ream ecosystem (TypeScript + Rust N-API). No floating-point drift.
+Exact decimal arithmetic, statistics, and currency-safe money values for the
+Ream ecosystem. Rust NAPI/WASM is used when available; the TypeScript BigInt
+engine is the fallback.
 
-Part of **[Ream](https://github.com/C9up/ream)** — a Rust-powered, AdonisJS-compatible Node.js framework. Independent, publishable package.
-
-## Installation
+## Install
 
 ```bash
 pnpm add @c9up/atom
 ```
 
-## Usage
+## Decimal
+
+```ts
+import { Decimal, decimal, sum } from '@c9up/atom'
+
+decimal('0.1').plus('0.2').toString() // "0.3"
+sum(['1.1', '2.2', '3.3']).toString() // "6.6"
+
+Decimal.safeParse('12.34') // { success: true, value: Decimal }
+Decimal.tryParse('bad') // null
+```
+
+Prefer string or bigint inputs for exact user/business data. Unsafe JS integer
+numbers are rejected.
+
+## Money
+
+```ts
+import { money, Money } from '@c9up/atom'
+
+const total = money('10.00', 'USD').allocate([1, 1, 1])
+total.map((part) => part.toString()) // ["3.34 USD", "3.33 USD", "3.33 USD"]
+
+Money.fromMinorUnits(1999n, 'EUR').format({ locale: 'fr-FR' })
+```
+
+`Money` keeps currency and scale together, and rejects operations across
+different currencies.
+
+## Context
+
+```ts
+import { configureAtomContext, decimal, withAtomContext } from '@c9up/atom'
+
+configureAtomContext({ precision: 8, roundMode: 'trunc' })
+withAtomContext({ precision: 2 }, () => decimal('1').div('8').toString())
+```
+
+## Atlas
 
 ```ts
-import { decimal, sum, avg, median, stddev } from '@c9up/atom'
+import { Column } from '@c9up/atlas'
+import { decimalColumn } from '@c9up/atom/atlas'
+
+class Invoice {
+  @Column(decimalColumn({ scale: 2, nullable: false }))
+  total!: Decimal
+}
+```
+
+## Scripts
 
-const price = decimal('19.99')          // exact decimal, no float drift
-sum(['1.1', '2.2', '3.3'])              // exact aggregate
-avg(values); median(values); stddev(values)
+```bash
+pnpm test
+pnpm test:napi
+pnpm test:coverage
+pnpm bench
+pnpm build:wasm && node scripts/verify-wasm.mjs
 ```
 
 ## Entry points
 
 - `@c9up/atom` — main API
-- `@c9up/atom/atlas` — Atlas integration adapter
+- `@c9up/atom/atlas` — Atlas column helpers
 
 ## License
 

package/dist/Decimal.d.ts

@@ -33,10 +33,21 @@ export interface ToMinorUnitsOptions {
     exact?: boolean;
     mode?: RoundMode;
 }
+export type DecimalSafeParseResult = {
+    success: true;
+    value: Decimal;
+} | {
+    success: false;
+    error: Error;
+};
 export declare class Decimal {
     #private;
-    constructor(value: DecimalInput);
+    constructor(value: DecimalInput, scaleHint?: number);
     static from(value: DecimalInput): Decimal;
+    static parse(value: DecimalInput): Decimal;
+    static tryParse(value: unknown): Decimal | null;
+    static safeParse(value: unknown): DecimalSafeParseResult;
+    static isDecimal(value: unknown): value is Decimal;
     static zero(): Decimal;
     static one(): Decimal;
     static fromMinorUnits(value: string | number | bigint, scale: number): Decimal;
@@ -132,6 +143,7 @@ export declare class Decimal {
      * Provided for interop with APIs that expect a primitive number.
      */
     toNumber(): number;
+    private sqrtTruncInt;
     /**
      * Format the value as a localized string via `Intl.NumberFormat`.
      *

package/dist/Decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Decimal.d.ts","sourceRoot":"","sources":["../src/Decimal.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Decimal.d.ts","sourceRoot":"","sources":["../src/Decimal.ts"],"names":[],"mappings":"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"}

package/dist/Decimal.js

@@ -1,13 +1,49 @@
-import { formatDecimal, parseDecimal, pow10BigInt } from "./math.js";
-import { nativeAtom } from "./native.js";
+import { defaultPrecision, defaultQuantizeMode, defaultRoundMode, } from "./context.js";
+import { addTs, cmpTs, divTs, formatDecimal, modTs, mulTs, parseDecimal, pow10BigInt, powTs, sqrtTs, subTs, } from "./math.js";
+import { tryNativeAtom } from "./native.js";
+const MAX_SCALE = 10_000;
+const MAX_EXPONENT_ABS = 100_000;
 export class Decimal {
     #value;
-    constructor(value) {
+    #scaleHint;
+    constructor(value, scaleHint) {
+        if (value instanceof Decimal) {
+            this.#value = value.#value;
+            this.#scaleHint = scaleHint ?? value.#scaleHint;
+            assertScale(this.#scaleHint);
+            return;
+        }
         this.#value = normalizeInput(value);
+        this.#scaleHint = scaleHint ?? inferInputScale(value, this.#value);
+        assertScale(this.#scaleHint);
     }
     static from(value) {
         return new Decimal(value);
     }
+    static parse(value) {
+        return new Decimal(value);
+    }
+    static tryParse(value) {
+        const parsed = Decimal.safeParse(value);
+        return parsed.success ? parsed.value : null;
+    }
+    static safeParse(value) {
+        try {
+            if (!isDecimalInput(value)) {
+                throw new Error(`Invalid decimal input type: ${typeof value}`);
+            }
+            return { success: true, value: new Decimal(value) };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+    }
+    static isDecimal(value) {
+        return value instanceof Decimal;
+    }
     static zero() {
         return new Decimal("0");
     }
@@ -27,56 +63,63 @@ export class Decimal {
     }
     plus(other) {
         const b = normalizeInput(other);
-        const result = nativeAtom().add(this.#value, b);
+        const native = tryNativeAtom();
+        const result = native ? native.add(this.#value, b) : addTs(this.#value, b);
         return new Decimal(result);
     }
     minus(other) {
         const b = normalizeInput(other);
-        const result = nativeAtom().sub(this.#value, b);
+        const native = tryNativeAtom();
+        const result = native ? native.sub(this.#value, b) : subTs(this.#value, b);
         return new Decimal(result);
     }
     times(other) {
         const b = normalizeInput(other);
-        const result = nativeAtom().mul(this.#value, b);
+        const native = tryNativeAtom();
+        const result = native ? native.mul(this.#value, b) : mulTs(this.#value, b);
         return new Decimal(result);
     }
     div(other, options = {}) {
         const b = normalizeInput(other);
-        const precision = options.precision ?? 18;
+        const precision = options.precision ?? defaultPrecision();
         assertScale(precision);
-        const result = nativeAtom().div(this.#value, b, precision);
+        const native = tryNativeAtom();
+        const result = native
+            ? native.div(this.#value, b, precision)
+            : divTs(this.#value, b, precision);
         return new Decimal(result);
     }
     mod(other) {
         const b = normalizeInput(other);
-        const result = nativeAtom().rem(this.#value, b);
+        const native = tryNativeAtom();
+        const result = native ? native.rem(this.#value, b) : modTs(this.#value, b);
         return new Decimal(result);
     }
     pow(exp, options = {}) {
-        if (!Number.isInteger(exp)) {
-            throw new Error(`Invalid exponent: ${exp}`);
-        }
-        const precision = options.precision ?? 18;
+        assertExponent(exp);
+        const precision = options.precision ?? defaultPrecision();
         assertScale(precision);
-        const result = nativeAtom().pow(this.#value, exp, precision);
+        const native = tryNativeAtom();
+        const result = native
+            ? native.pow(this.#value, exp, precision)
+            : powTs(this.#value, exp, precision);
         return new Decimal(result);
     }
     sqrt(options = {}) {
-        const precision = options.precision ?? 18;
-        const mode = options.mode ?? "trunc";
+        const precision = options.precision ?? defaultPrecision();
+        const mode = options.mode ?? defaultRoundMode();
         assertScale(precision);
         if (mode === "trunc") {
-            const result = nativeAtom().sqrt(this.#value, precision);
-            return new Decimal(result);
+            return fromIntScale(this.sqrtTruncInt(precision), precision);
         }
-        const withExtra = nativeAtom().sqrt(this.#value, precision + 1);
-        const parsed = parseDecimal(withExtra);
-        const rounded = roundIntScale(parsed.int, precision + 1, precision, mode);
+        const truncated = this.sqrtTruncInt(precision);
+        const rounded = roundSqrtInt(this.#value, truncated, precision, mode);
         return fromIntScale(rounded, precision);
     }
     cmp(other) {
         const b = normalizeInput(other);
-        const result = nativeAtom().cmp(this.#value, b);
+        const native = tryNativeAtom();
+        const result = native ? native.cmp(this.#value, b) : cmpTs(this.#value, b);
         if (result < 0)
             return -1;
         if (result > 0)
@@ -172,15 +215,19 @@ export class Decimal {
      *     new Decimal('1.025').quantize('0.05')  // → Decimal('1.05')
      */
     quantize(step, options = {}) {
-        const { mode = "half-up" } = options;
+        const { mode = defaultQuantizeMode() } = options;
         const stepValue = new Decimal(step);
         if (!stepValue.gt(0)) {
             throw new Error("Quantize step must be greater than zero");
         }
-        const thisScale = this.toParts().scale;
-        const stepScale = stepValue.toParts().scale;
-        const precision = options.precision ?? Math.max(18, thisScale + stepScale + 6);
-        const units = this.div(stepValue, { precision }).round(0, mode);
+        if (options.precision !== undefined) {
+            assertScale(options.precision);
+        }
+        const thisParts = parseDecimal(this.#value);
+        const stepParts = parseDecimal(stepValue.#value);
+        const numerator = thisParts.int * pow10BigInt(stepParts.scale);
+        const denominator = stepParts.int * pow10BigInt(thisParts.scale);
+        const units = fromIntScale(roundRationalToInt(numerator, denominator, mode), 0);
         return units.times(stepValue);
     }
     toScale(scale = 0, mode = "trunc") {
@@ -282,9 +329,9 @@ export class Decimal {
         if (ratioTotal <= 0n) {
             throw new Error("Allocate requires at least one positive ratio");
         }
-        const parsed = parseDecimal(this.#value);
-        const sign = parsed.int < 0n ? -1n : 1n;
-        const total = parsed.int < 0n ? -parsed.int : parsed.int;
+        const parsed = this.toParts();
+        const sign = parsed.value < 0n ? -1n : 1n;
+        const total = parsed.value < 0n ? -parsed.value : parsed.value;
         const baseShares = [];
         const remainders = [];
         let consumed = 0n;
@@ -317,7 +364,13 @@ export class Decimal {
     }
     toParts() {
         const parsed = parseDecimal(this.#value);
-        return { value: parsed.int, scale: parsed.scale };
+        if (this.#scaleHint <= parsed.scale) {
+            return { value: parsed.int, scale: parsed.scale };
+        }
+        return {
+            value: parsed.int * pow10BigInt(this.#scaleHint - parsed.scale),
+            scale: this.#scaleHint,
+        };
     }
     toString() {
         return this.#value;
@@ -333,6 +386,14 @@ export class Decimal {
     toNumber() {
         return Number(this.#value);
     }
+    sqrtTruncInt(precision) {
+        const native = tryNativeAtom();
+        const result = native
+            ? native.sqrt(this.#value, precision)
+            : sqrtTs(this.#value, precision);
+        const parsed = parseDecimal(result);
+        return roundIntScale(parsed.int, parsed.scale, precision, "trunc");
+    }
     /**
      * Format the value as a localized string via `Intl.NumberFormat`.
      *
@@ -369,10 +430,60 @@ function normalizeInput(value) {
         if (!Number.isFinite(value)) {
             throw new Error(`Invalid decimal: ${value}`);
         }
-        return normalizeDecimalString(String(value));
+        return normalizeDecimalString(decimalStringFromNumber(value));
     }
     return normalizeDecimalString(value);
 }
+function isDecimalInput(value) {
+    return (value instanceof Decimal ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "bigint");
+}
+function inferInputScale(value, normalized) {
+    if (typeof value === "bigint")
+        return 0;
+    if (typeof value === "number") {
+        return parseDecimal(decimalStringFromNumber(value)).scale;
+    }
+    try {
+        return parseDecimal(value).scale;
+    }
+    catch {
+        return parseDecimal(normalized).scale;
+    }
+}
+function decimalStringFromNumber(value) {
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+        throw new Error(`Unsafe integer decimal input: ${value}`);
+    }
+    const raw = String(value);
+    if (!/[eE]/.test(raw))
+        return raw;
+    const [coefficient, exponentRaw] = raw.toLowerCase().split("e");
+    const exponent = Number(exponentRaw);
+    if (!Number.isInteger(exponent)) {
+        throw new Error(`Invalid decimal: ${value}`);
+    }
+    const negative = coefficient.startsWith("-");
+    const unsigned = negative || coefficient.startsWith("+")
+        ? coefficient.slice(1)
+        : coefficient;
+    const [wholeRaw, fracRaw = ""] = unsigned.split(".");
+    const digits = `${wholeRaw}${fracRaw}`;
+    const decimalIndex = wholeRaw.length + exponent;
+    let expanded;
+    if (decimalIndex <= 0) {
+        expanded = `0.${"0".repeat(-decimalIndex)}${digits}`;
+    }
+    else if (decimalIndex >= digits.length) {
+        expanded = `${digits}${"0".repeat(decimalIndex - digits.length)}`;
+    }
+    else {
+        expanded = `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+    }
+    return negative ? `-${expanded}` : expanded;
+}
 function normalizeDecimalString(input) {
     const parsed = parseDecimal(input);
     return formatDecimal(parsed.int, parsed.scale);
@@ -384,6 +495,9 @@ function parseIntegerInput(value) {
         if (!Number.isInteger(value)) {
             throw new Error(`Invalid integer: ${value}`);
         }
+        if (!Number.isSafeInteger(value)) {
+            throw new Error(`Unsafe integer input: ${value}`);
+        }
         return BigInt(value);
     }
     const s = value.trim();
@@ -393,13 +507,20 @@ function parseIntegerInput(value) {
     return BigInt(s);
 }
 function fromIntScale(int, scale) {
-    return new Decimal(formatDecimal(int, scale));
+    return new Decimal(formatDecimal(int, scale), scale);
 }
 function assertScale(scale) {
-    if (!Number.isInteger(scale) || scale < 0) {
+    if (!Number.isInteger(scale) || scale < 0 || scale > MAX_SCALE) {
         throw new Error(`Invalid scale: ${scale}`);
     }
 }
+function assertExponent(exp) {
+    if (!Number.isInteger(exp) ||
+        exp < -MAX_EXPONENT_ABS ||
+        exp > MAX_EXPONENT_ABS) {
+        throw new Error(`Invalid exponent: ${exp}`);
+    }
+}
 function roundIntScale(int, sourceScale, targetScale, mode) {
     if (targetScale >= sourceScale) {
         return int * pow10BigInt(targetScale - sourceScale);
@@ -439,6 +560,73 @@ function roundIntScale(int, sourceScale, targetScale, mode) {
             throw new Error(`Unknown rounding mode: ${String(mode)}`);
     }
 }
+function roundRationalToInt(numerator, denominator, mode) {
+    if (denominator <= 0n) {
+        throw new Error("Invalid rational denominator");
+    }
+    const q = numerator / denominator;
+    const r = numerator % denominator;
+    if (r === 0n)
+        return q;
+    const absR = r < 0n ? -r : r;
+    const sign = numerator < 0n ? -1n : 1n;
+    switch (mode) {
+        case "trunc":
+            return q;
+        case "floor":
+            return numerator < 0n ? q - 1n : q;
+        case "ceil":
+            return numerator > 0n ? q + 1n : q;
+        case "half-up":
+            return absR * 2n >= denominator ? q + sign : q;
+        case "half-even": {
+            const twice = absR * 2n;
+            if (twice < denominator)
+                return q;
+            if (twice > denominator)
+                return q + sign;
+            const isEven = (q < 0n ? -q : q) % 2n === 0n;
+            return isEven ? q : q + sign;
+        }
+        default:
+            throw new Error(`Unknown rounding mode: ${String(mode)}`);
+    }
+}
+function roundSqrtInt(value, truncated, precision, mode) {
+    const parsed = parseDecimal(value);
+    if (parsed.int < 0n) {
+        throw new Error("Cannot compute sqrt of a negative decimal");
+    }
+    const squareCmp = compareScaled(truncated * truncated, 2 * precision, parsed.int, parsed.scale);
+    if (mode === "floor")
+        return truncated;
+    if (mode === "ceil") {
+        return squareCmp === 0 ? truncated : truncated + 1n;
+    }
+    const thresholdCmp = compareScaled((2n * truncated + 1n) * (2n * truncated + 1n), 2 * precision, 4n * parsed.int, parsed.scale);
+    if (thresholdCmp < 0)
+        return truncated + 1n;
+    if (thresholdCmp > 0)
+        return truncated;
+    if (mode === "half-up")
+        return truncated + 1n;
+    return truncated % 2n === 0n ? truncated : truncated + 1n;
+}
+function compareScaled(leftInt, leftScale, rightInt, rightScale) {
+    let left = leftInt;
+    let right = rightInt;
+    if (leftScale > rightScale) {
+        right *= pow10BigInt(leftScale - rightScale);
+    }
+    else if (rightScale > leftScale) {
+        left *= pow10BigInt(rightScale - leftScale);
+    }
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
 function isRosettaLike(arg) {
     return (typeof arg === "object" &&
         arg !== null &&
@@ -463,8 +651,6 @@ function normalizeViaRosetta(input, rosetta) {
         plusSign: raw.plusSign || "+",
     };
     let normalized = trimmed.replace(/\s| | /g, "");
-    normalized = normalized.replace(new RegExp(escapeRegExp(data.group), "g"), "");
-    normalized = normalized.replace(new RegExp(escapeRegExp(data.decimal), "g"), ".");
     if (data.minus !== "-") {
         normalized = normalized.replace(new RegExp(escapeRegExp(data.minus), "g"), "-");
     }
@@ -477,6 +663,9 @@ function normalizeViaRosetta(input, rosetta) {
     if (/^\(.*\)$/.test(normalized)) {
         normalized = `-${normalized.slice(1, -1)}`;
     }
+    validateLocalizedSyntax(normalized, data.group, data.decimal);
+    normalized = normalized.replace(new RegExp(escapeRegExp(data.group), "g"), "");
+    normalized = normalized.replace(new RegExp(escapeRegExp(data.decimal), "g"), ".");
     if (!/^[+-]?\d+(\.\d+)?$/.test(normalized)) {
         throw new Error(`Invalid localized decimal: ${input}`);
     }
@@ -492,9 +681,8 @@ function normalizeLocaleNumber(input, locales) {
     const group = parts.find((part) => part.type === "group")?.value ?? ",";
     const decimal = parts.find((part) => part.type === "decimal")?.value ?? ".";
     const minus = parts.find((part) => part.type === "minusSign")?.value ?? "-";
-    let normalized = trimmed.replace(/\s|\u00A0|\u202F/g, "");
-    normalized = normalized.replace(new RegExp(escapeRegExp(group), "g"), "");
-    normalized = normalized.replace(new RegExp(escapeRegExp(decimal), "g"), ".");
+    let normalized = normalizeLocaleDigits(trimmed, locales);
+    normalized = normalized.replace(/\s|\u00A0|\u202F/g, "");
     if (minus !== "-") {
         normalized = normalized.replace(new RegExp(escapeRegExp(minus), "g"), "-");
     }
@@ -502,11 +690,96 @@ function normalizeLocaleNumber(input, locales) {
     if (/^\(.*\)$/.test(normalized)) {
         normalized = `-${normalized.slice(1, -1)}`;
     }
+    validateLocalizedSyntax(normalized, group, decimal, getLocaleGrouping(locales));
+    normalized = normalized.replace(new RegExp(escapeRegExp(group), "g"), "");
+    normalized = normalized.replace(new RegExp(escapeRegExp(decimal), "g"), ".");
     if (!/^[+-]?\d+(\.\d+)?$/.test(normalized)) {
         throw new Error(`Invalid localized decimal: ${input}`);
     }
     return normalized;
 }
+function normalizeLocaleDigits(input, locales) {
+    const digitMap = getLocaleDigitMap(locales);
+    let out = "";
+    for (const char of input) {
+        out += digitMap.get(char) ?? char;
+    }
+    return out;
+}
+function getLocaleDigitMap(locales) {
+    const formatter = new Intl.NumberFormat(locales, { useGrouping: false });
+    const digits = formatter.format(9876543210);
+    const map = new Map();
+    let value = 9;
+    for (const char of digits) {
+        if (!map.has(char) && value >= 0) {
+            map.set(char, String(value));
+            value--;
+        }
+    }
+    return map;
+}
+function getLocaleGrouping(locales) {
+    const parts = new Intl.NumberFormat(locales)
+        .formatToParts(1234567890123)
+        .filter((part) => part.type === "integer" || part.type === "group");
+    const lengths = [];
+    let current = 0;
+    for (const part of parts) {
+        if (part.type === "integer") {
+            current += [...part.value].length;
+        }
+        else {
+            lengths.push(current);
+            current = 0;
+        }
+    }
+    lengths.push(current);
+    if (lengths.length < 2) {
+        return { primary: 3, secondary: 3 };
+    }
+    const primary = lengths[lengths.length - 1];
+    const secondary = lengths[lengths.length - 2] ?? primary;
+    return { primary, secondary };
+}
+function validateLocalizedSyntax(value, group, decimal, grouping = { primary: 3, secondary: 3 }) {
+    const decimalParts = value.split(decimal);
+    if (decimalParts.length > 2) {
+        throw new Error(`Invalid localized decimal: ${value}`);
+    }
+    let integer = decimalParts[0] ?? "";
+    const fraction = decimalParts[1];
+    if (integer.startsWith("+") || integer.startsWith("-")) {
+        integer = integer.slice(1);
+    }
+    if (!integer) {
+        throw new Error(`Invalid localized decimal: ${value}`);
+    }
+    if (fraction !== undefined && !/^\d+$/.test(fraction)) {
+        throw new Error(`Invalid localized decimal: ${value}`);
+    }
+    if (!integer.includes(group)) {
+        if (!/^\d+$/.test(integer)) {
+            throw new Error(`Invalid localized decimal: ${value}`);
+        }
+        return;
+    }
+    const groups = integer.split(group);
+    if (groups.some((part) => !/^\d+$/.test(part))) {
+        throw new Error(`Invalid localized decimal: ${value}`);
+    }
+    for (let i = groups.length - 1, distance = 0; i >= 0; i--, distance++) {
+        const size = distance === 0 ? grouping.primary : grouping.secondary;
+        if (i === 0) {
+            if (groups[i].length < 1 || groups[i].length > size) {
+                throw new Error(`Invalid localized decimal: ${value}`);
+            }
+        }
+        else if (groups[i].length !== size) {
+            throw new Error(`Invalid localized decimal: ${value}`);
+        }
+    }
+}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }