@iov/encoding - npm Package Compare versions

Comparing version 0.9.0 to 0.10.0

build/index.js

@@ -7,3 +7,7 @@ "use strict";
 __export(require("./encoding"));
-__export(require("./integers"));
+var integers_1 = require("./integers");
+exports.Int53 = integers_1.Int53;
+exports.Uint32 = integers_1.Uint32;
+exports.Uint53 = integers_1.Uint53;
+exports.Uint64 = integers_1.Uint64;
 //# sourceMappingURL=index.js.map

build/integers.js

@@ -43,5 +43,12 @@ "use strict";
     }
-    asNumber() {
+    toNumber() {
         return this.data;
     }
+    toString() {
+        return this.data.toString();
+    }
+    /** @deprecated use toNumber() */
+    asNumber() {
+        return this.toNumber();
+    }
 }
@@ -76,2 +83,22 @@ exports.Uint32 = Uint32;
 exports.Int53 = Int53;
+class Uint53 {
+    static fromString(str) {
+        const signed = Int53.fromString(str);
+        return new Uint53(signed.toNumber());
+    }
+    constructor(input) {
+        const signed = new Int53(input);
+        if (signed.toNumber() < 0) {
+            throw new Error("Input is negative");
+        }
+        this.data = signed;
+    }
+    toNumber() {
+        return this.data.toNumber();
+    }
+    toString() {
+        return this.data.toString();
+    }
+}
+exports.Uint53 = Uint53;
 class Uint64 {
@@ -78,0 +105,0 @@ static fromBytesBigEndian(bytes) {

build/integers.spec.js

@@ -32,11 +32,20 @@ "use strict";
         });
-        it("can convert back to number", () => {
-            expect(new integers_1.Uint32(0).asNumber()).toEqual(0);
-            expect(new integers_1.Uint32(1).asNumber()).toEqual(1);
-            expect(new integers_1.Uint32(42).asNumber()).toEqual(42);
-            expect(new integers_1.Uint32(1000000000).asNumber()).toEqual(1000000000);
-            expect(new integers_1.Uint32(2147483647).asNumber()).toEqual(2147483647);
-            expect(new integers_1.Uint32(2147483648).asNumber()).toEqual(2147483648);
-            expect(new integers_1.Uint32(4294967295).asNumber()).toEqual(4294967295);
+        it("can convert to number", () => {
+            expect(new integers_1.Uint32(0).toNumber()).toEqual(0);
+            expect(new integers_1.Uint32(1).toNumber()).toEqual(1);
+            expect(new integers_1.Uint32(42).toNumber()).toEqual(42);
+            expect(new integers_1.Uint32(1000000000).toNumber()).toEqual(1000000000);
+            expect(new integers_1.Uint32(2147483647).toNumber()).toEqual(2147483647);
+            expect(new integers_1.Uint32(2147483648).toNumber()).toEqual(2147483648);
+            expect(new integers_1.Uint32(4294967295).toNumber()).toEqual(4294967295);
         });
+        it("can convert to string", () => {
+            expect(new integers_1.Uint32(0).toString()).toEqual("0");
+            expect(new integers_1.Uint32(1).toString()).toEqual("1");
+            expect(new integers_1.Uint32(42).toString()).toEqual("42");
+            expect(new integers_1.Uint32(1000000000).toString()).toEqual("1000000000");
+            expect(new integers_1.Uint32(2147483647).toString()).toEqual("2147483647");
+            expect(new integers_1.Uint32(2147483648).toString()).toEqual("2147483648");
+            expect(new integers_1.Uint32(4294967295).toString()).toEqual("4294967295");
+        });
         it("can convert to byte array", () => {
@@ -53,18 +62,18 @@ expect(new integers_1.Uint32(0).toBytesBigEndian()).toEqual([0, 0, 0, 0]);
             it("can be constructed from to byte array", () => {
-                expect(integers_1.Uint32.fromBigEndianBytes([0, 0, 0, 0]).asNumber()).toEqual(0);
-                expect(integers_1.Uint32.fromBigEndianBytes([0, 0, 0, 1]).asNumber()).toEqual(1);
-                expect(integers_1.Uint32.fromBigEndianBytes([0, 0, 0, 42]).asNumber()).toEqual(42);
-                expect(integers_1.Uint32.fromBigEndianBytes([0x3b, 0x9a, 0xca, 0x00]).asNumber()).toEqual(1000000000);
-                expect(integers_1.Uint32.fromBigEndianBytes([0x7f, 0xff, 0xff, 0xff]).asNumber()).toEqual(2147483647);
-                expect(integers_1.Uint32.fromBigEndianBytes([0x80, 0x00, 0x00, 0x00]).asNumber()).toEqual(2147483648);
-                expect(integers_1.Uint32.fromBigEndianBytes([0xff, 0xff, 0xff, 0xff]).asNumber()).toEqual(4294967295);
+                expect(integers_1.Uint32.fromBigEndianBytes([0, 0, 0, 0]).toNumber()).toEqual(0);
+                expect(integers_1.Uint32.fromBigEndianBytes([0, 0, 0, 1]).toNumber()).toEqual(1);
+                expect(integers_1.Uint32.fromBigEndianBytes([0, 0, 0, 42]).toNumber()).toEqual(42);
+                expect(integers_1.Uint32.fromBigEndianBytes([0x3b, 0x9a, 0xca, 0x00]).toNumber()).toEqual(1000000000);
+                expect(integers_1.Uint32.fromBigEndianBytes([0x7f, 0xff, 0xff, 0xff]).toNumber()).toEqual(2147483647);
+                expect(integers_1.Uint32.fromBigEndianBytes([0x80, 0x00, 0x00, 0x00]).toNumber()).toEqual(2147483648);
+                expect(integers_1.Uint32.fromBigEndianBytes([0xff, 0xff, 0xff, 0xff]).toNumber()).toEqual(4294967295);
             });
             it("can be constructed from Buffer", () => {
-                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 0])).asNumber()).toEqual(0);
-                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 1])).asNumber()).toEqual(1);
-                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 42])).asNumber()).toEqual(42);
-                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0x3b, 0x9a, 0xca, 0x00])).asNumber()).toEqual(1000000000);
-                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0x7f, 0xff, 0xff, 0xff])).asNumber()).toEqual(2147483647);
-                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0x80, 0x00, 0x00, 0x00])).asNumber()).toEqual(2147483648);
-                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0xff, 0xff, 0xff, 0xff])).asNumber()).toEqual(4294967295);
+                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 0])).toNumber()).toEqual(0);
+                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 1])).toNumber()).toEqual(1);
+                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 42])).toNumber()).toEqual(42);
+                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0x3b, 0x9a, 0xca, 0x00])).toNumber()).toEqual(1000000000);
+                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0x7f, 0xff, 0xff, 0xff])).toNumber()).toEqual(2147483647);
+                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0x80, 0x00, 0x00, 0x00])).toNumber()).toEqual(2147483648);
+                expect(integers_1.Uint32.fromBigEndianBytes(Buffer.from([0xff, 0xff, 0xff, 0xff])).toNumber()).toEqual(4294967295);
             });
@@ -157,2 +166,65 @@ it("throws for invalid input length", () => {
     });
+    describe("Uint53", () => {
+        it("can be constructed", () => {
+            expect(new integers_1.Uint53(0)).toBeTruthy();
+            expect(new integers_1.Uint53(1)).toBeTruthy();
+            expect(new integers_1.Uint53(1.0)).toBeTruthy();
+            expect(new integers_1.Uint53(42)).toBeTruthy();
+            expect(new integers_1.Uint53(1000000000)).toBeTruthy();
+            expect(new integers_1.Uint53(2147483647)).toBeTruthy();
+            expect(new integers_1.Uint53(2147483648)).toBeTruthy();
+            expect(new integers_1.Uint53(4294967295)).toBeTruthy();
+            expect(new integers_1.Uint53(9007199254740991)).toBeTruthy();
+        });
+        it("throws for invald numbers", () => {
+            expect(() => new integers_1.Uint53(NaN)).toThrowError(/not a number/);
+            expect(() => new integers_1.Uint53(1.1)).toThrowError(/not an integer/i);
+            expect(() => new integers_1.Uint53(Number.NEGATIVE_INFINITY)).toThrowError(/not an integer/i);
+            expect(() => new integers_1.Uint53(Number.POSITIVE_INFINITY)).toThrowError(/not an integer/i);
+        });
+        it("throws for values out of range", () => {
+            expect(() => new integers_1.Uint53(Number.MIN_SAFE_INTEGER - 1)).toThrowError(/not in int53 range/);
+            expect(() => new integers_1.Uint53(Number.MAX_SAFE_INTEGER + 1)).toThrowError(/not in int53 range/);
+        });
+        it("throws for negative inputs", () => {
+            expect(() => new integers_1.Uint53(-1)).toThrowError(/is negative/);
+            expect(() => new integers_1.Uint53(-42)).toThrowError(/is negative/);
+            expect(() => new integers_1.Uint53(-2147483648)).toThrowError(/is negative/);
+            expect(() => new integers_1.Uint53(-2147483649)).toThrowError(/is negative/);
+            expect(() => new integers_1.Uint53(-9007199254740991)).toThrowError(/is negative/);
+        });
+        it("can convert to number", () => {
+            expect(new integers_1.Uint53(0).toNumber()).toEqual(0);
+            expect(new integers_1.Uint53(1).toNumber()).toEqual(1);
+            expect(new integers_1.Uint53(42).toNumber()).toEqual(42);
+            expect(new integers_1.Uint53(1000000000).toNumber()).toEqual(1000000000);
+            expect(new integers_1.Uint53(2147483647).toNumber()).toEqual(2147483647);
+            expect(new integers_1.Uint53(2147483648).toNumber()).toEqual(2147483648);
+            expect(new integers_1.Uint53(4294967295).toNumber()).toEqual(4294967295);
+            expect(new integers_1.Uint53(9007199254740991).toNumber()).toEqual(9007199254740991);
+        });
+        it("can convert to string", () => {
+            expect(new integers_1.Uint53(0).toString()).toEqual("0");
+            expect(new integers_1.Uint53(1).toString()).toEqual("1");
+            expect(new integers_1.Uint53(42).toString()).toEqual("42");
+            expect(new integers_1.Uint53(1000000000).toString()).toEqual("1000000000");
+            expect(new integers_1.Uint53(2147483647).toString()).toEqual("2147483647");
+            expect(new integers_1.Uint53(2147483648).toString()).toEqual("2147483648");
+            expect(new integers_1.Uint53(4294967295).toString()).toEqual("4294967295");
+            expect(new integers_1.Uint53(9007199254740991).toString()).toEqual("9007199254740991");
+        });
+        it("can be constructed from string", () => {
+            expect(integers_1.Uint53.fromString("0").toString()).toEqual("0");
+            expect(integers_1.Uint53.fromString("1").toString()).toEqual("1");
+            expect(integers_1.Uint53.fromString("9007199254740991").toString()).toEqual("9007199254740991");
+        });
+        it("throws for invalid string format", () => {
+            expect(() => integers_1.Uint53.fromString(" 0")).toThrowError(/invalid string format/i);
+            expect(() => integers_1.Uint53.fromString("+0")).toThrowError(/invalid string format/i);
+            expect(() => integers_1.Uint53.fromString("1e6")).toThrowError(/invalid string format/i);
+            expect(() => integers_1.Uint53.fromString("-9007199254740992")).toThrowError(/input not in int53 range/i);
+            expect(() => integers_1.Uint53.fromString("9007199254740992")).toThrowError(/input not in int53 range/i);
+            expect(() => integers_1.Uint53.fromString("-1")).toThrowError(/input is negative/i);
+        });
+    });
     describe("Uint64", () => {
@@ -159,0 +231,0 @@ it("can be constructed from bytes", () => {

package.json

 {
   "name": "@iov/encoding",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Encoding helpers for IOV projects",
@@ -26,3 +26,3 @@ "author": "IOV SAS <[e-mail]>",
     "test": "yarn build-or-skip && yarn test-node",
-    "prebuild": "yarn format && yarn lint",
+    "prebuild": "yarn format",
     "move-types": "shx rm -r ./types/* && shx mv build/types/* ./types && shx rm ./types/*.spec.d.ts",
@@ -43,3 +43,3 @@ "build": "shx rm -rf ./build && tsc && yarn move-types",
   },
-  "gitHead": "2b178ec5efdb25691163cb250024386028e2e50a"
+  "gitHead": "c6258401ce9238f81c4db78927c702e6db165f63"
 }

src/index.ts

 export * from "./encoding";
-export * from "./integers";
+export { Int53, Uint32, Uint53, Uint64 } from "./integers";

src/integers.spec.ts

@@ -1,2 +0,2 @@
-import { Int53, Uint32, Uint64 } from "./integers";
+import { Int53, Uint32, Uint53, Uint64 } from "./integers";
 
@@ -39,12 +39,22 @@ describe("Integers", () => {
 
-    it("can convert back to number", () => {
-      expect(new Uint32(0).asNumber()).toEqual(0);
-      expect(new Uint32(1).asNumber()).toEqual(1);
-      expect(new Uint32(42).asNumber()).toEqual(42);
-      expect(new Uint32(1000000000).asNumber()).toEqual(1000000000);
-      expect(new Uint32(2147483647).asNumber()).toEqual(2147483647);
-      expect(new Uint32(2147483648).asNumber()).toEqual(2147483648);
-      expect(new Uint32(4294967295).asNumber()).toEqual(4294967295);
+    it("can convert to number", () => {
+      expect(new Uint32(0).toNumber()).toEqual(0);
+      expect(new Uint32(1).toNumber()).toEqual(1);
+      expect(new Uint32(42).toNumber()).toEqual(42);
+      expect(new Uint32(1000000000).toNumber()).toEqual(1000000000);
+      expect(new Uint32(2147483647).toNumber()).toEqual(2147483647);
+      expect(new Uint32(2147483648).toNumber()).toEqual(2147483648);
+      expect(new Uint32(4294967295).toNumber()).toEqual(4294967295);
     });
 
+    it("can convert to string", () => {
+      expect(new Uint32(0).toString()).toEqual("0");
+      expect(new Uint32(1).toString()).toEqual("1");
+      expect(new Uint32(42).toString()).toEqual("42");
+      expect(new Uint32(1000000000).toString()).toEqual("1000000000");
+      expect(new Uint32(2147483647).toString()).toEqual("2147483647");
+      expect(new Uint32(2147483648).toString()).toEqual("2147483648");
+      expect(new Uint32(4294967295).toString()).toEqual("4294967295");
+    });
+
     it("can convert to byte array", () => {
@@ -62,19 +72,19 @@ expect(new Uint32(0).toBytesBigEndian()).toEqual([0, 0, 0, 0]);
       it("can be constructed from to byte array", () => {
-        expect(Uint32.fromBigEndianBytes([0, 0, 0, 0]).asNumber()).toEqual(0);
-        expect(Uint32.fromBigEndianBytes([0, 0, 0, 1]).asNumber()).toEqual(1);
-        expect(Uint32.fromBigEndianBytes([0, 0, 0, 42]).asNumber()).toEqual(42);
-        expect(Uint32.fromBigEndianBytes([0x3b, 0x9a, 0xca, 0x00]).asNumber()).toEqual(1000000000);
-        expect(Uint32.fromBigEndianBytes([0x7f, 0xff, 0xff, 0xff]).asNumber()).toEqual(2147483647);
-        expect(Uint32.fromBigEndianBytes([0x80, 0x00, 0x00, 0x00]).asNumber()).toEqual(2147483648);
-        expect(Uint32.fromBigEndianBytes([0xff, 0xff, 0xff, 0xff]).asNumber()).toEqual(4294967295);
+        expect(Uint32.fromBigEndianBytes([0, 0, 0, 0]).toNumber()).toEqual(0);
+        expect(Uint32.fromBigEndianBytes([0, 0, 0, 1]).toNumber()).toEqual(1);
+        expect(Uint32.fromBigEndianBytes([0, 0, 0, 42]).toNumber()).toEqual(42);
+        expect(Uint32.fromBigEndianBytes([0x3b, 0x9a, 0xca, 0x00]).toNumber()).toEqual(1000000000);
+        expect(Uint32.fromBigEndianBytes([0x7f, 0xff, 0xff, 0xff]).toNumber()).toEqual(2147483647);
+        expect(Uint32.fromBigEndianBytes([0x80, 0x00, 0x00, 0x00]).toNumber()).toEqual(2147483648);
+        expect(Uint32.fromBigEndianBytes([0xff, 0xff, 0xff, 0xff]).toNumber()).toEqual(4294967295);
       });
 
       it("can be constructed from Buffer", () => {
-        expect(Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 0])).asNumber()).toEqual(0);
-        expect(Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 1])).asNumber()).toEqual(1);
-        expect(Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 42])).asNumber()).toEqual(42);
-        expect(Uint32.fromBigEndianBytes(Buffer.from([0x3b, 0x9a, 0xca, 0x00])).asNumber()).toEqual(1000000000);
-        expect(Uint32.fromBigEndianBytes(Buffer.from([0x7f, 0xff, 0xff, 0xff])).asNumber()).toEqual(2147483647);
-        expect(Uint32.fromBigEndianBytes(Buffer.from([0x80, 0x00, 0x00, 0x00])).asNumber()).toEqual(2147483648);
-        expect(Uint32.fromBigEndianBytes(Buffer.from([0xff, 0xff, 0xff, 0xff])).asNumber()).toEqual(4294967295);
+        expect(Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 0])).toNumber()).toEqual(0);
+        expect(Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 1])).toNumber()).toEqual(1);
+        expect(Uint32.fromBigEndianBytes(Buffer.from([0, 0, 0, 42])).toNumber()).toEqual(42);
+        expect(Uint32.fromBigEndianBytes(Buffer.from([0x3b, 0x9a, 0xca, 0x00])).toNumber()).toEqual(1000000000);
+        expect(Uint32.fromBigEndianBytes(Buffer.from([0x7f, 0xff, 0xff, 0xff])).toNumber()).toEqual(2147483647);
+        expect(Uint32.fromBigEndianBytes(Buffer.from([0x80, 0x00, 0x00, 0x00])).toNumber()).toEqual(2147483648);
+        expect(Uint32.fromBigEndianBytes(Buffer.from([0xff, 0xff, 0xff, 0xff])).toNumber()).toEqual(4294967295);
       });
@@ -189,2 +199,76 @@
 
+  describe("Uint53", () => {
+    it("can be constructed", () => {
+      expect(new Uint53(0)).toBeTruthy();
+      expect(new Uint53(1)).toBeTruthy();
+      expect(new Uint53(1.0)).toBeTruthy();
+      expect(new Uint53(42)).toBeTruthy();
+      expect(new Uint53(1000000000)).toBeTruthy();
+      expect(new Uint53(2147483647)).toBeTruthy();
+      expect(new Uint53(2147483648)).toBeTruthy();
+      expect(new Uint53(4294967295)).toBeTruthy();
+      expect(new Uint53(9007199254740991)).toBeTruthy();
+    });
+
+    it("throws for invald numbers", () => {
+      expect(() => new Uint53(NaN)).toThrowError(/not a number/);
+
+      expect(() => new Uint53(1.1)).toThrowError(/not an integer/i);
+      expect(() => new Uint53(Number.NEGATIVE_INFINITY)).toThrowError(/not an integer/i);
+      expect(() => new Uint53(Number.POSITIVE_INFINITY)).toThrowError(/not an integer/i);
+    });
+
+    it("throws for values out of range", () => {
+      expect(() => new Uint53(Number.MIN_SAFE_INTEGER - 1)).toThrowError(/not in int53 range/);
+      expect(() => new Uint53(Number.MAX_SAFE_INTEGER + 1)).toThrowError(/not in int53 range/);
+    });
+
+    it("throws for negative inputs", () => {
+      expect(() => new Uint53(-1)).toThrowError(/is negative/);
+      expect(() => new Uint53(-42)).toThrowError(/is negative/);
+      expect(() => new Uint53(-2147483648)).toThrowError(/is negative/);
+      expect(() => new Uint53(-2147483649)).toThrowError(/is negative/);
+      expect(() => new Uint53(-9007199254740991)).toThrowError(/is negative/);
+    });
+
+    it("can convert to number", () => {
+      expect(new Uint53(0).toNumber()).toEqual(0);
+      expect(new Uint53(1).toNumber()).toEqual(1);
+      expect(new Uint53(42).toNumber()).toEqual(42);
+      expect(new Uint53(1000000000).toNumber()).toEqual(1000000000);
+      expect(new Uint53(2147483647).toNumber()).toEqual(2147483647);
+      expect(new Uint53(2147483648).toNumber()).toEqual(2147483648);
+      expect(new Uint53(4294967295).toNumber()).toEqual(4294967295);
+      expect(new Uint53(9007199254740991).toNumber()).toEqual(9007199254740991);
+    });
+
+    it("can convert to string", () => {
+      expect(new Uint53(0).toString()).toEqual("0");
+      expect(new Uint53(1).toString()).toEqual("1");
+      expect(new Uint53(42).toString()).toEqual("42");
+      expect(new Uint53(1000000000).toString()).toEqual("1000000000");
+      expect(new Uint53(2147483647).toString()).toEqual("2147483647");
+      expect(new Uint53(2147483648).toString()).toEqual("2147483648");
+      expect(new Uint53(4294967295).toString()).toEqual("4294967295");
+      expect(new Uint53(9007199254740991).toString()).toEqual("9007199254740991");
+    });
+
+    it("can be constructed from string", () => {
+      expect(Uint53.fromString("0").toString()).toEqual("0");
+      expect(Uint53.fromString("1").toString()).toEqual("1");
+      expect(Uint53.fromString("9007199254740991").toString()).toEqual("9007199254740991");
+    });
+
+    it("throws for invalid string format", () => {
+      expect(() => Uint53.fromString(" 0")).toThrowError(/invalid string format/i);
+      expect(() => Uint53.fromString("+0")).toThrowError(/invalid string format/i);
+      expect(() => Uint53.fromString("1e6")).toThrowError(/invalid string format/i);
+
+      expect(() => Uint53.fromString("-9007199254740992")).toThrowError(/input not in int53 range/i);
+      expect(() => Uint53.fromString("9007199254740992")).toThrowError(/input not in int53 range/i);
+
+      expect(() => Uint53.fromString("-1")).toThrowError(/input is negative/i);
+    });
+  });
+
   describe("Uint64", () => {
@@ -191,0 +275,0 @@ it("can be constructed from bytes", () => {

src/integers.ts

@@ -6,3 +6,9 @@ /* tslint:disable:no-bitwise */
 
-export class Uint32 {
+// internal interface to ensure all integer types can be used equally
+interface Integer {
+  readonly toNumber: () => number;
+  readonly toString: () => string;
+}
+
+export class Uint32 implements Integer {
   public static fromBigEndianBytes(bytes: ArrayLike<number>): Uint32 {
@@ -54,8 +60,17 @@ if (bytes.length !== 4) {
 
-  public asNumber(): number {
+  public toNumber(): number {
     return this.data;
   }
+
+  public toString(): string {
+    return this.data.toString();
+  }
+
+  /** @deprecated use toNumber() */
+  public asNumber(): number {
+    return this.toNumber();
+  }
 }
 
-export class Int53 {
+export class Int53 implements Integer {
   public static fromString(str: string): Int53 {
@@ -96,3 +111,28 @@ if (!str.match(/^\-?[0-9]+$/)) {
 
-export class Uint64 {
+export class Uint53 implements Integer {
+  public static fromString(str: string): Uint53 {
+    const signed = Int53.fromString(str);
+    return new Uint53(signed.toNumber());
+  }
+
+  protected readonly data: Int53;
+
+  constructor(input: number) {
+    const signed = new Int53(input);
+    if (signed.toNumber() < 0) {
+      throw new Error("Input is negative");
+    }
+    this.data = signed;
+  }
+
+  public toNumber(): number {
+    return this.data.toNumber();
+  }
+
+  public toString(): string {
+    return this.data.toString();
+  }
+}
+
+export class Uint64 implements Integer {
   public static fromBytesBigEndian(bytes: ArrayLike<number>): Uint64 {
@@ -99,0 +139,0 @@ if (bytes.length !== 8) {

types/index.d.ts

 export * from "./encoding";
-export * from "./integers";
+export { Int53, Uint32, Uint53, Uint64 } from "./integers";

types/integers.d.ts

@@ -1,2 +0,6 @@
-export declare class Uint32 {
+interface Integer {
+    readonly toNumber: () => number;
+    readonly toString: () => string;
+}
+export declare class Uint32 implements Integer {
     static fromBigEndianBytes(bytes: ArrayLike<number>): Uint32;
@@ -6,5 +10,8 @@ protected readonly data: number;
     toBytesBigEndian(): ReadonlyArray<number>;
+    toNumber(): number;
+    toString(): string;
+    /** @deprecated use toNumber() */
     asNumber(): number;
 }
-export declare class Int53 {
+export declare class Int53 implements Integer {
     static fromString(str: string): Int53;
@@ -16,3 +23,10 @@ protected readonly data: number;
 }
-export declare class Uint64 {
+export declare class Uint53 implements Integer {
+    static fromString(str: string): Uint53;
+    protected readonly data: Int53;
+    constructor(input: number);
+    toNumber(): number;
+    toString(): string;
+}
+export declare class Uint64 implements Integer {
     static fromBytesBigEndian(bytes: ArrayLike<number>): Uint64;
@@ -28,1 +42,2 @@ static fromString(str: string): Uint64;
 }
+export {};

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

190383

increased by10.01%

Lines of code

2041

increased by12.2%

No dependency changes