first commit

core/schemas/json_wasm.go

@@ -0,0 +1,92 @@
+//go:build tinygo || wasm
+
+package schemas
+
+import (
+	"bytes"
+	"encoding/json"
+)
+
+// Marshal encodes v to JSON bytes using the standard library.
+func Marshal(v interface{}) ([]byte, error) {
+	return json.Marshal(v)
+}
+
+// MarshalString encodes v to a JSON string using the standard library.
+func MarshalString(v interface{}) (string, error) {
+	data, err := json.Marshal(v)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// Unmarshal decodes JSON data into v using the standard library.
+func Unmarshal(data []byte, v interface{}) error {
+	return json.Unmarshal(data, v)
+}
+
+// Compact removes insignificant whitespace from JSON-encoded src
+// and appends the result to dst.
+func Compact(dst *bytes.Buffer, src []byte) error {
+	return json.Compact(dst, src)
+}
+
+// MarshalSorted encodes v to JSON with map keys sorted alphabetically.
+// Use this when deterministic output is needed (e.g., hashing, caching keys).
+// Recursively normalizes OrderedMap values to plain maps so json.Marshal sorts keys.
+func MarshalSorted(v interface{}) ([]byte, error) {
+	normalized := normalizeForSortedMarshal(v)
+	return json.Marshal(normalized)
+}
+
+// MarshalDeeplySorted encodes v to JSON with all map keys sorted alphabetically,
+// including nested maps inside OrderedMap and other custom types with MarshalJSON.
+// This ensures fully deterministic output for hashing/caching purposes.
+// In WASM builds, this is equivalent to MarshalSorted since both normalize recursively.
+func MarshalDeeplySorted(v interface{}) ([]byte, error) {
+	normalized := normalizeForSortedMarshal(v)
+	return json.Marshal(normalized)
+}
+
+// normalizeForSortedMarshal recursively converts OrderedMaps and structs to plain maps
+// so that json.Marshal will sort their keys (Go 1.12+ sorts map keys).
+func normalizeForSortedMarshal(v interface{}) interface{} {
+	if v == nil {
+		return nil
+	}
+
+	switch val := v.(type) {
+	case *OrderedMap:
+		if val == nil {
+			return nil
+		}
+		result := make(map[string]interface{}, val.Len())
+		val.Range(func(k string, v interface{}) bool {
+			result[k] = normalizeForSortedMarshal(v)
+			return true
+		})
+		return result
+	case OrderedMap:
+		result := make(map[string]interface{}, val.Len())
+		val.Range(func(k string, v interface{}) bool {
+			result[k] = normalizeForSortedMarshal(v)
+			return true
+		})
+		return result
+	case map[string]interface{}:
+		result := make(map[string]interface{}, len(val))
+		for k, v := range val {
+			result[k] = normalizeForSortedMarshal(v)
+		}
+		return result
+	case []interface{}:
+		result := make([]interface{}, len(val))
+		for i, elem := range val {
+			result[i] = normalizeForSortedMarshal(elem)
+		}
+		return result
+	default:
+		return v
+	}
+}