Add support for NaN/Infinity serialization

Author: exyi

src/Framework/Framework/Configuration/DefaultSerializerSettingsProvider.cs

@@ -8,6 +8,7 @@
 using System.Text.Json.Serialization;
 using System.Text.Encodings.Web;
 using System.Text.Unicode;
+using DotVVM.Framework.Utils;
 
 namespace DotVVM.Framework.Configuration
 {
@@ -41,6 +42,9 @@ private JsonSerializerOptions CreateSettings()
 #if !DotNetCore
                     new DotvvmTimeOnlyJsonConverter(),
                     new DotvvmDateOnlyJsonConverter(),
+#endif
+#if NET6_0_OR_GREATER
+                    new HalfJsonConverter(),
 #endif
                 },
                 NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals,

src/Framework/Framework/Resources/Scripts/metadata/coercer.ts

@@ -1,4 +1,5 @@
 import { serializeDate } from "../serialization/date";
+import { jsonStringify } from "../serialization/serialize";
 import { CoerceError } from "../shared-classes";
 import { keys } from "../utils/objects";
 import { tryCoerceEnum } from "./enums";
@@ -101,7 +102,7 @@ function tryCoerceArray(value: any, innerType: TypeDefinition, originalValue: an
             return { value: items, wasCoerced: true };
         }
     }
-    return new CoerceError(`Value '${JSON.stringify(value)}' is not an array of type '${formatTypeName(innerType)}'.`);
+    return new CoerceError(`Value '${jsonStringify(value)}' is not an array of type '${formatTypeName(innerType)}'.`);
 }
 
 function tryCoercePrimitiveType(value: any, type: string): CoerceResult {

src/Framework/Framework/Resources/Scripts/metadata/primitiveTypes.ts

@@ -108,6 +108,10 @@ function validateFloat(value: any) {
     if (isNumber(value)) {
         return { value: +value, wasCoerced: value !== +value };
     }
+
+    if (value != value || value === "NaN") {
+        return { value: NaN, wasCoerced: value == value }
+    }
 }
 
 function validateString(value: any) {

src/Framework/Framework/Resources/Scripts/postback/postbackCore.ts

@@ -15,6 +15,7 @@ import { isPrimitive } from '../utils/objects';
 import * as stateManager from '../state-manager'
 import { mapUpdatableProperties } from '../serialization/deserialize';
 import { logError } from '../utils/logging';
+import { jsonStringify } from '../serialization/serialize';
 
 let lastStartedPostbackId: number;
 
@@ -77,7 +78,7 @@ export async function postbackCore(
         }
 
         const initialUrl = getInitialUrl();
-        let response = await http.postJSON<PostbackResponse>(initialUrl, JSON.stringify(data), options.abortSignal);
+        let response = await http.postJSON<PostbackResponse>(initialUrl, jsonStringify(data), options.abortSignal);
 
         if (response.result.action == "viewModelNotCached") {
             // repeat the request with full viewmodel
@@ -87,7 +88,7 @@ export async function postbackCore(
             delete data.viewModelCache;
             data.viewModel = postedViewModel;
 
-            response = await http.postJSON<PostbackResponse>(initialUrl, JSON.stringify(data), options.abortSignal);
+            response = await http.postJSON<PostbackResponse>(initialUrl, jsonStringify(data), options.abortSignal);
         }
 
         events.postbackResponseReceived.trigger({

src/Framework/Framework/Resources/Scripts/postback/staticCommand.ts

@@ -1,4 +1,4 @@
-import { serialize } from '../serialization/serialize';
+import { jsonStringify, serialize } from '../serialization/serialize';
 import { getInitialUrl, getViewModel } from '../dotvvm-base';
 import * as events from '../events';
 import * as http from './http'
@@ -60,7 +60,7 @@ export async function staticCommandPostback(command: string, args: any[], option
 
         response = await http.postJSON<DotvvmStaticCommandResponse>(
             getInitialUrl(),
-            JSON.stringify(data),
+            jsonStringify(data),
             options.abortSignal,
             { "X-PostbackType": "StaticCommand" }
         );

src/Framework/Framework/Resources/Scripts/serialization/serialize.ts

@@ -125,3 +125,14 @@ function findObject(obj: any, matcher: (o: any) => boolean): string[] | null {
     }
     return null;
 }
+
+export function jsonStringify(value: any, indent = compileConstants.debug ? "    " : undefined): string {
+    return JSON.stringify(value, (key, val) => {
+        if (typeof val === "number") {
+            if (!isFinite(val)) {
+                return String(val)
+            }
+        }
+        return val
+    }, indent)
+}

src/Framework/Framework/Resources/Scripts/shared-classes.ts

@@ -1,7 +1,9 @@
+import { jsonStringify } from "./serialization/serialize"
+
 export class DotvvmPostbackError {
     constructor(public reason: DotvvmPostbackErrorReason) {
     }
-    toString() { return "PostbackRejectionError(" + JSON.stringify(this.reason, null, "   ") + ")"}
+    toString() { return "PostbackRejectionError(" + jsonStringify(this.reason) + ")"}
 }
 
 export class CoerceError extends Error implements CoerceErrorType {

src/Framework/Framework/Resources/Scripts/state-manager.ts

@@ -56,8 +56,9 @@ export class StateManager<TViewModel extends { $type?: TypeDefinition }> impleme
         initialState: DeepReadonly<TViewModel>,
         public stateUpdateEvent?: DotvvmEvent<DeepReadonly<TViewModel>>
     ) {
-        this._state = coerce(initialState, initialState.$type || { type: "dynamic" })
-        this.stateObservable = createWrappedObservable(initialState, (initialState as any)["$type"], () => this._state, u => this.updateState(u as any))
+        const type = initialState.$type
+        this._state = coerce(initialState, type || { type: "dynamic" })
+        this.stateObservable = createWrappedObservable(this._state, type, () => this._state, u => this.updateState(u as any))
         this.dispatchUpdate()
     }
 

src/Framework/Framework/Resources/Scripts/tests/coercer.test.ts

@@ -113,6 +113,42 @@ test("number - valid, convert from string and keep decimal places", () => {
     expect(result.value).toEqual(1234.56);
 })
 
+test("float - special values, NaN from string", () => {
+    const result = tryCoerce("NaN", "Single");
+    expect(result.wasCoerced).toBeTruthy();
+    expect(Number.isNaN(result.value)).toBeTruthy();
+})
+
+test("float - special values, Infinity from string", () => {
+    const result = tryCoerce("Infinity", "Single");
+    expect(result.wasCoerced).toBeTruthy();
+    expect(result.value).toEqual(Infinity);
+})
+
+test("float - special values, -Infinity from string", () => {
+    const result = tryCoerce("-Infinity", "Single");
+    expect(result.wasCoerced).toBeTruthy();
+    expect(result.value).toEqual(-Infinity);
+})
+
+test("double - special values, NaN from string", () => {
+    const result = tryCoerce("NaN", "Double");
+    expect(result.wasCoerced).toBeTruthy();
+    expect(Number.isNaN(result.value)).toBeTruthy();
+})
+
+test("double - special values, Infinity from string", () => {
+    const result = tryCoerce("Infinity", "Double");
+    expect(result.wasCoerced).toBeTruthy();
+    expect(result.value).toEqual(Infinity);
+})
+
+test("double - special values, -Infinity from string", () => {
+    const result = tryCoerce("-Infinity", "Double");
+    expect(result.wasCoerced).toBeTruthy();
+    expect(result.value).toEqual(-Infinity);
+})
+
 test("number - invalid, out of range", () => {
     const result = tryCoerce(100000, "Int16");
     expect(result.isError).toBeTruthy();

src/Framework/Framework/Resources/Scripts/tests/serialization.test.ts

@@ -1,6 +1,6 @@
 import dotvvm from '../dotvvm-root'
 import { deserialize } from '../serialization/deserialize'
-import { serialize } from '../serialization/serialize'
+import { serialize, jsonStringify } from '../serialization/serialize'
 import { serializeDate } from '../serialization/date'
 import { tryCoerce } from '../metadata/coercer';
 import { createComplexObservableSubViewmodel, createComplexObservableViewmodel, ObservableHierarchy, ObservableSubHierarchy, ObservableSubSubHierarchy } from "./observableHierarchies"
@@ -676,6 +676,12 @@ describe("DotVVM.Serialization - serialize", () => {
         expect(d).toBe("2015-08-01T13:56:42.0000000")
     })
 
+    test("jsonStringify - float special values", () => {
+        const data = [1, NaN, Infinity, -Infinity, 2];
+        const result = jsonStringify(data);
+        expect(result).toBe(`[\n    1,\n    "NaN",\n    "Infinity",\n    "-Infinity",\n    2\n]`)
+    })
+
     test("Serialize object with Date property", () => {
         const obj = serialize({
             $type: ko.observable("t3"),