Addressing issue 309:

MemoryPackWriter.ts now writes Uint32/Uint64 rather than Float32/Float64 as the 'HasValue' flag for nullable float and double respectively.
MemoryPackReader.ts now reads Uint32/Uint64 rather than Float32/Float64 as the 'HasValue' flag for nullable float and double respectively.
Added new tests to SandboxWebApp.

Author: Mike Reynolds

sandbox/SandboxWebApp/Controllers/MemoryPackController.cs

@@ -12,4 +12,18 @@ public AllConvertableType Post([FromBody] AllConvertableType value)
     {
         return value;
     }
+
+    [Route("nullableFloat")]
+    [HttpPost]
+    public NullableFloatTest PostNullableTest([FromBody] NullableFloatTest input)
+    {
+        var ret = new NullableFloatTest
+        {
+            // If you're curious about the '* 1.0' part, DM me :-)
+            NullableFloat = input.NullableFloat * 1.0F,
+            NullableDouble = input.NullableDouble * 1.0D
+        };
+
+        return ret;
+    }
 }

sandbox/SandboxWebApp/Models.cs

@@ -190,3 +190,11 @@ public partial class Rec
 {
     public required Rec Id { get; init; }
 }
+
+[MemoryPackable]
+[GenerateTypeScript]
+public partial class NullableFloatTest
+{
+    public float? NullableFloat { get; set; }
+    public double? NullableDouble { get; set; }
+}

sandbox/SandboxWebApp/Pages/Index.cshtml

@@ -7,13 +7,19 @@
 <script type="module">
     import { test } from "./js/file.js";
     import { test2 } from "./js/file.js";
+    import { testNullableFloatWithValues } from "./js/file.js";
+    import { testNullableFloatWithNulls } from "./js/file.js";
     import { hoge } from "./js/file.js";
     import { huga } from "./js/file.js";
 
     //hoge();
     //huga();
     test();
     test2();
+
+    testNullableFloatWithValues();
+    testNullableFloatWithNulls();
+
 </script>
 
 <div class="text-center">

sandbox/SandboxWebApp/wwwroot/js/file.js

@@ -10,6 +10,7 @@ import { Subset } from "./memorypack/Subset.js";
 import { SampleUnion2 } from "./memorypack/SampleUnion2.js";
 import { Person } from "./memorypack/Person.js";
 import { Gender } from "./memorypack/Gender.js";
+import { NullableFloatTest } from "./memorypack/NullableFloatTest.js";
 
 export async function hoge() {
 
@@ -207,6 +208,57 @@ export async function test2() {
     assertObject(v, v2!);
 }
 
+export async function testNullableFloatWithValues()
+{
+    const input = new NullableFloatTest();
+    input.nullableFloat = 31413.431251;
+    input.nullableDouble = 9932.425252;
+
+    const bin = NullableFloatTest.serialize(input);
+    const blob = new Blob([bin.buffer], { type: "application/x-memorypack" })
+    const response = await fetch("http://localhost:5260/api/nullableFloat", { method: "POST", body: blob, headers: { "Content-Type": "application/x-memorypack" } });
+
+    if (response.status != 200) {
+        console.log(response.status);
+        return;
+    }
+
+    const buffer = await response.arrayBuffer();
+    const output = NullableFloatTest.deserialize(buffer);
+    assertNullableFloat(input, output!);
+
+    console.log("testNullableFloatWithValues passed.");
+}
+
+export async function testNullableFloatWithNulls() {
+    const input = new NullableFloatTest();
+    input.nullableFloat = null;
+    input.nullableDouble = null;
+
+    const bin = NullableFloatTest.serialize(input);
+    const blob = new Blob([bin.buffer], { type: "application/x-memorypack" })
+    const response = await fetch("http://localhost:5260/api/nullableFloat", { method: "POST", body: blob, headers: { "Content-Type": "application/x-memorypack" } });
+
+    if (response.status != 200) {
+        console.log(response.status);
+        return;
+    }
+
+    const buffer = await response.arrayBuffer();
+    const output = NullableFloatTest.deserialize(buffer);
+
+    assertIsNull(output!.nullableFloat);
+    assertIsNull(output!.nullableDouble);
+
+    console.log("testNullableFloatWithNulls passed.");
+}
+
+function assertNullableFloat(a: NullableFloatTest, b: NullableFloatTest): void
+{
+    ok(a.nullableFloat?.toFixed(1), b.nullableFloat?.toFixed(1))
+    ok(a.nullableDouble?.toFixed(1), b.nullableDouble?.toFixed(1))
+}
+
 function assertObject(v: AllConvertableType, v2: AllConvertableType): void {
     ok(v.myBool, v2.myBool);
     ok(v.myByte, v2.myByte);
@@ -280,6 +332,12 @@ function assertObject(v: AllConvertableType, v2: AllConvertableType): void {
     console.log("test passed");
 }
 
+function assertIsNull(value: any) : void
+{
+    if (value !== null)
+        throw new Error("Invalid: value must be null.");
+}
+
 function ok(v1: any, v2: any): void {
     if (v1 === v2) return;
     throw new Error("Invalid v1:" + v1 + " v2:" + v2);

sandbox/SandboxWebApp/wwwroot/js/file.js.map

@@ -202,7 +202,7 @@ export class MemoryPackReader {
     }
 
     public readNullableFloat32(): number | null {
-        if (this.readFloat32() == FALSE) {
+        if (this.readUint32() == FALSE) {
             this.offset += 4;
             return null;
         }
@@ -217,7 +217,7 @@ export class MemoryPackReader {
     }
 
     public readNullableFloat64(): number | null {
-        if (this.readFloat64() == FALSE) {
+        if (this.readUint64() == 0n) {
             this.offset += 8;
             return null;
         }
@@ -386,4 +386,4 @@ export class MemoryPackReader {
         this.offset += length;
         return new Uint8Array(span);
     }
-}
+}