4.0.0 base -> core and encode -> toBytes

Author: Gekctek

mops.toml

@@ -1,14 +1,14 @@
 [package]
 name = "cbor"
-version = "3.0.0"
+version = "4.0.0"
 description = "A CBOR library for encoding and decoding CBOR bytes"
 repository = "https://github.com/edjcase/motoko_cbor"
-keywords = ["cbor", "encoding"]
+keywords = [ "cbor", "encoding" ]
 license = "MIT"
 
 [dependencies]
-base = "0.14.14"
-xtended-numbers = "0.4.0"
+core = "0.6.0"
+xtended-numbers = "2.0.0"
 
 [dev-dependencies]
 test = "2.1.1"

src/Decoder.mo

@@ -1,16 +1,15 @@
 import NatX "mo:xtended-numbers/NatX";
 import FloatX "mo:xtended-numbers/FloatX";
-import Blob "mo:base/Blob";
-import Buffer "mo:base/Buffer";
-import Int "mo:base/Int";
-import Int64 "mo:base/Int64";
-import Iter "mo:base/Iter";
-import Nat "mo:base/Nat";
-import Nat64 "mo:base/Nat64";
-import Nat8 "mo:base/Nat8";
-import Result "mo:base/Result";
-import Text "mo:base/Text";
-import Util "./Util";
+import Blob "mo:core/Blob";
+import Int "mo:core/Int";
+import Int64 "mo:core/Int64";
+import Iter "mo:core/Iter";
+import Nat "mo:core/Nat";
+import Nat64 "mo:core/Nat64";
+import Nat8 "mo:core/Nat8";
+import Result "mo:core/Result";
+import Text "mo:core/Text";
+import List "mo:core/List";
 import Types "./Types";
 
 /// CBOR (Concise Binary Object Representation) decoder for Motoko.
@@ -29,7 +28,7 @@ import Types "./Types";
 /// Example usage:
 /// ```motoko
 /// import CBOR "mo:cbor";
-/// import Result "mo:base/Result";
+/// import Result "mo:core/Result";
 ///
 /// // Decode CBOR bytes to a value
 /// let bytes: [Nat8] = [0x18, 0x2a]; // CBOR encoding of integer 42
@@ -64,7 +63,7 @@ module {
   /// ```motoko
   /// let bytes: [Nat8] = [0xbf, 0x63, 0x46, 0x75, 0x6e, 0xf5, 0x63, 0x41, 0x6d, 0x74, 0x21, 0xff];
   /// let cbor: Types.Value = switch(fromBytes(bytes.vals())) {
-  ///     case (#err(e)) Debug.trap("Decoding failed: " # debug_show(e));
+  ///     case (#err(e)) Runtime.trap("Decoding failed: " # debug_show(e));
   ///     case (#ok(c)) c;
   /// };
   /// ```
@@ -197,28 +196,28 @@ module {
         };
         case (#ok(#indef)) {
           // Loop indefinitely for each array item
-          let buffer = Buffer.Buffer<Types.Value>(1);
+          let buffer = List.empty<Types.Value>();
           label l loop {
             let cbor_value : Types.Value = switch (decodeInternal(true)) {
               case (#err(e)) return #err(e);
               case (#ok(#majorType7(#_break))) break l;
               case (#ok(v)) v;
             };
-            buffer.add(cbor_value);
+            List.add(buffer, cbor_value);
           };
-          return #ok(#majorType4(Buffer.toArray(buffer)));
+          return #ok(#majorType4(List.toArray(buffer)));
         };
         case (#err(x)) return #err(x);
       };
-      let buffer = Buffer.Buffer<Types.Value>(Nat64.toNat(array_length));
-      for (i in Iter.range(1, Nat64.toNat(array_length))) {
+      let buffer = List.empty<Types.Value>();
+      for (i in Nat.range(1, Nat64.toNat(array_length) + 1)) {
         let cbor_value : Types.Value = switch (decodeInternal(false)) {
           case (#err(e)) return #err(e);
           case (#ok(v)) v;
         };
-        buffer.add(cbor_value);
+        List.add(buffer, cbor_value);
       };
-      #ok(#majorType4(Buffer.toArray(buffer)));
+      #ok(#majorType4(List.toArray(buffer)));
     };
 
     private func parseMajorType5(additionalBits : Nat8) : Result.Result<Types.Value, Types.DecodingError> {
@@ -232,28 +231,28 @@ module {
         };
         case (#ok(#indef)) {
           // Loop indefinitely for each array item
-          let buffer = Buffer.Buffer<(Types.Value, Types.Value)>(1);
+          let buffer = List.empty<(Types.Value, Types.Value)>();
           label l loop {
             let (key, value) = switch (decodeKeyValuePair()) {
               case (#err(#unexpectedBreak)) break l;
               case (#err(e)) return #err(e);
               case (#ok(v)) v;
             };
-            buffer.add((key, value));
+            List.add(buffer, (key, value));
           };
-          return #ok(#majorType5(Buffer.toArray(buffer)));
+          return #ok(#majorType5(List.toArray(buffer)));
         };
         case (#err(x)) return #err(x);
       };
-      let buffer = Buffer.Buffer<(Types.Value, Types.Value)>(Nat64.toNat(map_size));
-      for (i in Iter.range(1, Nat64.toNat(map_size))) {
+      let buffer = List.empty<(Types.Value, Types.Value)>();
+      for (i in Nat.range(1, Nat64.toNat(map_size) + 1)) {
         let (key, value) = switch (decodeKeyValuePair()) {
           case (#err(e)) return #err(e);
           case (#ok(v)) v;
         };
-        buffer.add((key, value));
+        List.add(buffer, (key, value));
       };
-      #ok(#majorType5(Buffer.toArray(buffer)));
+      #ok(#majorType5(List.toArray(buffer)));
     };
 
     private func parseMajorType6(additionalBits : Nat8) : Result.Result<Types.Value, Types.DecodingError> {
@@ -315,7 +314,7 @@ module {
       let value = switch (readBytes(byteLength)) {
         case (null) return #err(#unexpectedEndOfBytes);
         case (?v) {
-          switch (FloatX.decode(Iter.fromArray(v), precision, #msb)) {
+          switch (FloatX.fromBytes(v.vals(), precision, #msb)) {
             case (null) return #err(#invalid("Invalid float value"));
             case (?v) v;
           };
@@ -339,20 +338,20 @@ module {
       if (n < 1) {
         return ?[];
       };
-      let iter : Iter.Iter<Nat> = Iter.range(1, n);
-      let buffer = Buffer.Buffer<Nat8>(n);
+      let iter : Iter.Iter<Nat> = Nat.range(1, n + 1);
+      let buffer = List.empty<Nat8>();
       for (i in iter) {
         let byte = switch (readByte()) {
           case (null) return null;
           case (?byte) byte;
         };
-        buffer.add(byte);
+        List.add(buffer, byte);
       };
-      return ?Buffer.toArray(buffer);
+      return ?List.toArray(buffer);
     };
 
     private func readIndefBytes(chunkedMajorType : ?Nat8) : Result.Result<[Nat8], Types.DecodingError> {
-      let buffer = Buffer.Buffer<Nat8>(1);
+      let buffer = List.empty<Nat8>();
       label l loop {
         let byte = switch (readByte()) {
           case (null) return #err(#unexpectedEndOfBytes);
@@ -362,7 +361,7 @@ module {
           break l; // Reached end of indefinate byte sequence
         };
         switch (chunkedMajorType) {
-          case (null) buffer.add(byte); // byte is actual byte value
+          case (null) List.add(buffer, byte); // byte is actual byte value
           case (?t) {
             // byte represents major type/additional bits of next byte chunk
             let (majorType, additionalBits) = parseMajorType(byte);
@@ -374,11 +373,11 @@ module {
               case (null) return #err(#unexpectedEndOfBytes);
               case (?v) v;
             };
-            Util.appendArrayToBuffer(buffer, bytes);
+            List.addAll(buffer, bytes.vals());
           };
         };
       };
-      return #ok(Buffer.toArray(buffer));
+      return #ok(List.toArray(buffer));
     };
 
     private func decodeKeyValuePair() : Result.Result<(Types.Value, Types.Value), Types.DecodingError> {
@@ -397,10 +396,10 @@ module {
       let iter = Iter.fromArray(bytes);
       // Convert bytes to value
       let result : ?Nat64 = switch (bytes.size()) {
-        case (1) do ? { NatX.from8To64(NatX.decodeNat8(iter, #msb)!) };
-        case (2) do ? { NatX.from16To64(NatX.decodeNat16(iter, #msb)!) };
-        case (4) do ? { NatX.from32To64(NatX.decodeNat32(iter, #msb)!) };
-        case (8) NatX.decodeNat64(iter, #msb);
+        case (1) do ? { NatX.from8To64(NatX.fromNat8Bytes(iter, #msb)!) };
+        case (2) do ? { NatX.from16To64(NatX.fromNat16Bytes(iter, #msb)!) };
+        case (4) do ? { NatX.from32To64(NatX.fromNat32Bytes(iter, #msb)!) };
+        case (8) NatX.fromNat64Bytes(iter, #msb);
         case (s) return #err(#invalid("Invalid additional bytes size: " # Nat.toText(s)));
       };
       switch (result) {