Support bigint arguments and safe integers (#92)

Author: jessealama

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [11.2.0] - 2024-03-29
+
+### Changed
+
+-   The Decimal128 constructor now accepts BigInt arguments as well as safe integer Numbers
+
 ## [11.1.0] - 2024-03-29
 
 ### Changed

src/decimal128.mts

@@ -1035,20 +1035,38 @@ export class Decimal128 {
     private readonly isNegative: boolean;
     private readonly rat;
 
-    constructor(n: string, options?: ConstructorOptions) {
+    constructor(n: string | number | bigint, options?: ConstructorOptions) {
         let data = undefined;
+        let s = "";
 
         let fullySpecifiedOptions =
             ensureFullySpecifiedConstructorOptions(options);
 
-        if (n.match(nanRegExp)) {
+        if ("number" === typeof n) {
+            if (!Number.isInteger(n)) {
+                throw new SyntaxError("Non-integer number not permitted");
+            }
+            if (!Number.isSafeInteger(n)) {
+                throw new RangeError(
+                    "Integer is too large to be exactly represented"
+                );
+            }
+
+            s = n.toString();
+        } else if ("bigint" === typeof n) {
+            s = n.toString();
+        } else {
+            s = n;
+        }
+
+        if (s.match(nanRegExp)) {
             data = handleNan();
-        } else if (n.match(exponentRegExp)) {
-            data = handleExponentialNotation(n, fullySpecifiedOptions);
-        } else if (n.match(digitStrRegExp)) {
-            data = handleDecimalNotation(n, fullySpecifiedOptions);
-        } else if (n.match(infRegExp)) {
-            data = handleInfinity(n);
+        } else if (s.match(exponentRegExp)) {
+            data = handleExponentialNotation(s, fullySpecifiedOptions);
+        } else if (s.match(digitStrRegExp)) {
+            data = handleDecimalNotation(s, fullySpecifiedOptions);
+        } else if (s.match(infRegExp)) {
+            data = handleInfinity(s);
         } else {
             throw new SyntaxError(`Illegal number format "${n}"`);
         }

tests/constructor.test.js

@@ -588,5 +588,35 @@ describe("General Decimal Arithmetic specification", () => {
             ).toStrictEqual("0E+2");
         });
     });
-    describe("engineering string", () => {});
+});
+
+describe("number arguments", () => {
+    test("integer", () => {
+        expect(new Decimal128(42).toString()).toStrictEqual("42");
+    });
+    test("non-integer number", () => {
+        expect(() => new Decimal128(42.5)).toThrow(SyntaxError);
+    });
+    test("NaN", () => {
+        expect(() => new Decimal128(NaN)).toThrow(SyntaxError);
+    });
+    test("minus zero", () => {
+        expect(new Decimal128(-0).toString()).toStrictEqual("0");
+    });
+    test("too big", () => {
+        expect(
+            () => new Decimal128(123456789012345678901234567890123456789)
+        ).toThrow(RangeError);
+    });
+});
+
+describe("bigint", () => {
+    test("simple", () => {
+        expect(new Decimal128(42n).toString()).toStrictEqual("42");
+    });
+    test("too big", () => {
+        expect(
+            () => new Decimal128(123456789012345678901234567890123456789n)
+        ).toThrow(RangeError);
+    });
 });