nodenetcdf 4.9.31 → 4.9.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodenetcdf",
-  "version": "4.9.31",
+  "version": "4.9.32",
   "description": "Read and write NodeNetCDF files",
   "main": "./build/Release/nodenetcdf.node",
   "types": "./index.d.ts",

package/src/Attribute.cpp

@@ -365,6 +365,21 @@ void Attribute::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
         }
         value = v8::Null(isolate);
     }
+    else if (value->IsTypedArray())
+    {
+        // Convert TypedArray to regular array for JSON serialization
+        v8::Local<v8::TypedArray> typedArray = v8::Local<v8::TypedArray>::Cast(value);
+        uint32_t length = typedArray->Length();
+        v8::Local<v8::Array> array = v8::Array::New(isolate, length);
+        
+        for (uint32_t i = 0; i < length; i++)
+        {
+            v8::Local<v8::Value> element = typedArray->Get(context, i).ToLocalChecked();
+            (void)array->Set(context, i, element);
+        }
+        value = array;
+    }
+    // Don't wrap primitives - only convert TypedArrays to arrays
     
     (void)json->CreateDataProperty(context, value_str, value);
     

package/src/Group.cpp

@@ -525,30 +525,72 @@ void Group::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
         }
     }
     
-    // Add dimensions, variables, attributes, subgroups
-    // These will be accessed through property getters which trigger the respective Get* methods
+    // Convert dimensions object to array
     v8::Local<v8::Value> dimensions = args.Holder()->Get(context, dimensions_str).ToLocalChecked();
-    if (dimensions->IsObject())
+    if (dimensions->IsObject() && !dimensions->IsNull())
     {
-        (void)json->CreateDataProperty(context, dimensions_str, dimensions);
+        v8::Local<v8::Object> dimsObj = dimensions->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = dimsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> dimsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = dimsObj->Get(context, key).ToLocalChecked();
+            (void)dimsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, dimensions_str, dimsArray);
     }
     
+    // Convert variables object to array
     v8::Local<v8::Value> variables = args.Holder()->Get(context, variables_str).ToLocalChecked();
-    if (variables->IsObject())
+    if (variables->IsObject() && !variables->IsNull())
     {
-        (void)json->CreateDataProperty(context, variables_str, variables);
+        v8::Local<v8::Object> varsObj = variables->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = varsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> varsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = varsObj->Get(context, key).ToLocalChecked();
+            (void)varsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, variables_str, varsArray);
     }
     
+    // Convert attributes object to array
     v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
-    if (attributes->IsObject())
+    if (attributes->IsObject() && !attributes->IsNull())
     {
-        (void)json->CreateDataProperty(context, attributes_str, attributes);
+        v8::Local<v8::Object> attrsObj = attributes->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = attrsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> attrsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = attrsObj->Get(context, key).ToLocalChecked();
+            (void)attrsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, attributes_str, attrsArray);
     }
     
+    // Convert subgroups object to array
     v8::Local<v8::Value> subgroups = args.Holder()->Get(context, subgroups_str).ToLocalChecked();
-    if (subgroups->IsObject())
+    if (subgroups->IsObject() && !subgroups->IsNull())
     {
-        (void)json->CreateDataProperty(context, subgroups_str, subgroups);
+        v8::Local<v8::Object> subgrpsObj = subgroups->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = subgrpsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> subgrpsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = subgrpsObj->Get(context, key).ToLocalChecked();
+            (void)subgrpsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, subgroups_str, subgrpsArray);
     }
     
     args.GetReturnValue().Set(json);

package/src/Variable.cpp

@@ -1383,18 +1383,28 @@ void Variable::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
     (void)json->CreateDataProperty(context, type_str,
               v8::String::NewFromUtf8(isolate, type_name, v8::NewStringType::kInternalized).ToLocalChecked());
     
-    // Add dimensions array with serialized dimension objects
+    // Dimensions are already an array, just add them
     v8::Local<v8::Value> dimensions = args.Holder()->Get(context, dimensions_str).ToLocalChecked();
     if (dimensions->IsArray())
     {
         (void)json->CreateDataProperty(context, dimensions_str, dimensions);
     }
     
-    // Add attributes object with serialized attribute objects
+    // Convert attributes object to array
     v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
-    if (attributes->IsObject())
+    if (attributes->IsObject() && !attributes->IsNull())
     {
-        (void)json->CreateDataProperty(context, attributes_str, attributes);
+        v8::Local<v8::Object> attrsObj = attributes->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = attrsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> attrsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = attrsObj->Get(context, key).ToLocalChecked();
+            (void)attrsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, attributes_str, attrsArray);
     }
     
     args.GetReturnValue().Set(json);

package/test/json.js

@@ -63,6 +63,40 @@ describe('JSON Serialization', function() {
                 }
             }
         });
+        
+        it('should not serialize attribute values as null', function() {
+            // Check all attributes in file don't have null values when serialized
+            var jsonStr = JSON.stringify(file);
+            var nullMatches = jsonStr.match(/"value":\s*null/g);
+            var nullCount = nullMatches ? nullMatches.length : 0;
+            
+            expect(nullCount).to.equal(0, 'Found ' + nullCount + ' null attribute values in JSON');
+        });
+        
+        it('should convert TypedArray values to regular arrays in JSON', function() {
+            // Find an attribute with a TypedArray value
+            var variables = file.root.variables;
+            for (var varName in variables) {
+                var variable = variables[varName];
+                var varAttrs = variable.attributes;
+                for (var attrName in varAttrs) {
+                    var attr = varAttrs[attrName];
+                    
+                    // Check if value is a TypedArray
+                    if (attr.value && typeof attr.value === 'object' && 
+                        attr.value.constructor && attr.value.constructor.name.includes('Array') &&
+                        !Array.isArray(attr.value)) {
+                        
+                        // It's a TypedArray, test it converts to regular array
+                        var json = JSON.parse(JSON.stringify(attr));
+                        
+                        // In JSON, it should be a regular array
+                        expect(Array.isArray(json.value)).to.be.true;
+                        return;
+                    }
+                }
+            }
+        });
     });
     
     describe('Variable', function() {