nodenetcdf 4.9.31 → 4.9.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodenetcdf",
-  "version": "4.9.31",
+  "version": "4.9.33",
   "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/File.cpp

@@ -174,11 +174,27 @@ void File::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
     v8::Isolate *isolate = args.GetIsolate();
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
     
-    // Get the root group and serialize it
+    // Get the root group
     v8::Local<v8::String> rootProp = v8::String::NewFromUtf8(isolate, "root", v8::NewStringType::kNormal).ToLocalChecked();
     v8::Local<v8::Value> root = args.Holder()->Get(context, rootProp).ToLocalChecked();
     
-    // The root group's toJSON will automatically serialize all children recursively
+    // Call toJSON on the root group to get proper array conversion
+    if (root->IsObject())
+    {
+        v8::Local<v8::Object> rootObj = root->ToObject(context).ToLocalChecked();
+        v8::Local<v8::String> toJSONProp = v8::String::NewFromUtf8(isolate, "toJSON", v8::NewStringType::kNormal).ToLocalChecked();
+        v8::Local<v8::Value> toJSONMethod = rootObj->Get(context, toJSONProp).ToLocalChecked();
+        
+        if (toJSONMethod->IsFunction())
+        {
+            v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSONMethod);
+            v8::Local<v8::Value> result = toJSONFunc->Call(context, rootObj, 0, nullptr).ToLocalChecked();
+            args.GetReturnValue().Set(result);
+            return;
+        }
+    }
+    
+    // Fallback: return root as-is
     args.GetReturnValue().Set(root);
 }
 } // namespace nodenetcdfjs

package/src/Group.cpp

@@ -525,30 +525,124 @@ 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, calling toJSON on each item
     v8::Local<v8::Value> dimensions = args.Holder()->Get(context, dimensions_str).ToLocalChecked();
-    if (dimensions->IsObject())
-    {
-        (void)json->CreateDataProperty(context, dimensions_str, dimensions);
+    if (dimensions->IsObject() && !dimensions->IsNull())
+    {
+        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());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
+        
+        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();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).ToLocalChecked();
+                }
+            }
+            (void)dimsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, dimensions_str, dimsArray);
     }
     
+    // Convert variables object to array, calling toJSON on each item
     v8::Local<v8::Value> variables = args.Holder()->Get(context, variables_str).ToLocalChecked();
-    if (variables->IsObject())
-    {
-        (void)json->CreateDataProperty(context, variables_str, variables);
+    if (variables->IsObject() && !variables->IsNull())
+    {
+        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());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
+        
+        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();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).ToLocalChecked();
+                }
+            }
+            (void)varsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, variables_str, varsArray);
     }
     
+    // Convert attributes object to array, calling toJSON on each item
     v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
-    if (attributes->IsObject())
-    {
-        (void)json->CreateDataProperty(context, attributes_str, attributes);
+    if (attributes->IsObject() && !attributes->IsNull())
+    {
+        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());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
+        
+        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();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).ToLocalChecked();
+                }
+            }
+            (void)attrsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, attributes_str, attrsArray);
     }
     
+    // Convert subgroups object to array, calling toJSON on each item
     v8::Local<v8::Value> subgroups = args.Holder()->Get(context, subgroups_str).ToLocalChecked();
-    if (subgroups->IsObject())
-    {
-        (void)json->CreateDataProperty(context, subgroups_str, subgroups);
+    if (subgroups->IsObject() && !subgroups->IsNull())
+    {
+        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());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
+        
+        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();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).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,62 @@ 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, but call toJSON on each item
     v8::Local<v8::Value> dimensions = args.Holder()->Get(context, dimensions_str).ToLocalChecked();
     if (dimensions->IsArray())
     {
-        (void)json->CreateDataProperty(context, dimensions_str, dimensions);
+        v8::Local<v8::Array> dimsArray = v8::Local<v8::Array>::Cast(dimensions);
+        v8::Local<v8::Array> newDimsArray = v8::Array::New(isolate, dimsArray->Length());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
+        
+        for (uint32_t i = 0; i < dimsArray->Length(); i++)
+        {
+            v8::Local<v8::Value> value = dimsArray->Get(context, i).ToLocalChecked();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).ToLocalChecked();
+                }
+            }
+            (void)newDimsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, dimensions_str, newDimsArray);
     }
     
-    // Add attributes object with serialized attribute objects
+    // Convert attributes object to array, calling toJSON on each item
     v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
-    if (attributes->IsObject())
-    {
-        (void)json->CreateDataProperty(context, attributes_str, attributes);
+    if (attributes->IsObject() && !attributes->IsNull())
+    {
+        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());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
+        
+        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();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).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() {
@@ -130,11 +164,15 @@ describe('JSON Serialization', function() {
         it('should recursively serialize entire file structure', function() {
             var json = JSON.parse(JSON.stringify(file));
             
-            // File should serialize as root group with all children
+            // File should serialize as root group with all children as arrays
             expect(json).to.have.property('dimensions');
             expect(json).to.have.property('variables');
-            expect(json.variables).to.be.an('object');
-            expect(json.dimensions).to.be.an('object');
+            expect(json).to.have.property('attributes');
+            expect(json).to.have.property('subgroups');
+            expect(json.variables).to.be.an('array');
+            expect(json.dimensions).to.be.an('array');
+            expect(json.attributes).to.be.an('array');
+            expect(json.subgroups).to.be.an('array');
         });
     });
 });