nodenetcdf 4.9.3 → 4.9.31

package/src/Dimension.cpp

@@ -25,6 +25,7 @@ void Dimension::Init(v8::Local<v8::Object> exports)
     tpl->SetClassName(v8::String::NewFromUtf8(isolate, "Dimension", v8::NewStringType::kNormal).ToLocalChecked());
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Dimension::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", Dimension::ToJSON);
     tpl->InstanceTemplate()->SetAccessor(
         v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal).ToLocalChecked(), Dimension::GetId);
     tpl->InstanceTemplate()->SetAccessor(
@@ -102,4 +103,39 @@ void Dimension::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object Dimension]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+void Dimension::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    const auto *obj = node::ObjectWrap::Unwrap<Dimension>(args.Holder());
+    
+    // Use internalized strings for better performance
+    v8::Local<v8::String> id_str = v8::String::NewFromUtf8Literal(isolate, "id");
+    v8::Local<v8::String> name_str = v8::String::NewFromUtf8Literal(isolate, "name");
+    v8::Local<v8::String> length_str = v8::String::NewFromUtf8Literal(isolate, "length");
+    
+    v8::Local<v8::Object> json = v8::Object::New(isolate);
+    
+    // Add id
+    (void)json->CreateDataProperty(context, id_str, v8::Integer::New(isolate, obj->id));
+    
+    // Add name
+    std::array<char, NC_MAX_NAME + 1> name{};
+    if (obj->get_name(name.data()))
+    {
+        (void)json->CreateDataProperty(context, name_str,
+                  v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked());
+    }
+    
+    // Add length
+    size_t len = 0;
+    const int retval = nc_inq_dimlen(obj->parent_id, obj->id, &len);
+    if (retval == NC_NOERR)
+    {
+        (void)json->CreateDataProperty(context, length_str, v8::Integer::New(isolate, static_cast<int32_t>(len)));
+    }
+    
+    args.GetReturnValue().Set(json);
+}
 } // namespace nodenetcdfjs

package/src/Dimension.h

@@ -30,6 +30,7 @@ class Dimension : public node::ObjectWrap
     static void SetName(v8::Local<v8::String> property, v8::Local<v8::Value> val,
                         const v8::PropertyCallbackInfo<void> &info);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     int id{-1};
     int parent_id{-1};

package/src/File.cpp

@@ -38,6 +38,7 @@ void File::Init(v8::Local<v8::Object> exports)
     NODE_SET_PROTOTYPE_METHOD(tpl, "sync", File::Sync);
     NODE_SET_PROTOTYPE_METHOD(tpl, "close", File::Close);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", File::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", File::ToJSON);
     constructor.Reset(isolate, tpl->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
     exports->Set(isolate->GetCurrentContext(),
                  v8::String::NewFromUtf8(isolate, "File", v8::NewStringType::kNormal).ToLocalChecked(),
@@ -167,4 +168,17 @@ void File::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object File]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+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
+    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
+    args.GetReturnValue().Set(root);
+}
 } // namespace nodenetcdfjs

package/src/File.h

@@ -30,6 +30,7 @@ class File : public node::ObjectWrap
     static void Close(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void Sync(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static v8::Persistent<v8::Function> constructor;
 

package/src/Group.cpp

@@ -31,6 +31,7 @@ void Group::Init(v8::Local<v8::Object> exports)
     NODE_SET_PROTOTYPE_METHOD(tpl, "addSubgroup", Group::AddSubgroup);
     NODE_SET_PROTOTYPE_METHOD(tpl, "addAttribute", Group::AddAttribute);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Group::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", Group::ToJSON);
     tpl->InstanceTemplate()->SetAccessor(
         v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal).ToLocalChecked(), Group::GetId);
     tpl->InstanceTemplate()->SetAccessor(
@@ -244,6 +245,7 @@ void Group::GetId(v8::Local<v8::String> property, const v8::PropertyCallbackInfo
 void Group::GetVariables(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int nvars = 0;
@@ -270,8 +272,8 @@ void Group::GetVariables(v8::Local<v8::String> property, const v8::PropertyCallb
         auto *v = new Variable(var_ids[i], obj->id);
         if (v->get_name(name.data()))
         {
-            result->Set(isolate->GetCurrentContext(),
-                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+            (void)result->CreateDataProperty(context,
+                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                         v->handle());
         }
         else
@@ -285,6 +287,7 @@ void Group::GetVariables(v8::Local<v8::String> property, const v8::PropertyCallb
 void Group::GetDimensions(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int ndims = 0;
@@ -311,10 +314,8 @@ void Group::GetDimensions(v8::Local<v8::String> property, const v8::PropertyCall
         auto *d = new Dimension(dim_ids[i], obj->id);
         if (d->get_name(name.data()))
         {
-            // Suppress warning about unused return value
-            (void)result->Set(
-                isolate->GetCurrentContext(),
-                v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+            (void)result->CreateDataProperty(context,
+                v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                 d->handle());
         }
         else
@@ -326,6 +327,7 @@ void Group::GetDimensions(v8::Local<v8::String> property, const v8::PropertyCall
 void Group::GetUnlimited(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int ndims = 0;
@@ -352,9 +354,8 @@ void Group::GetUnlimited(v8::Local<v8::String> property, const v8::PropertyCallb
         auto *d = new Dimension(dim_ids[i], obj->id);
         if (d->get_name(name.data()))
         {
-             // Suppress warning about unused return value
-             (void)result->Set(isolate->GetCurrentContext(),
-                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+             (void)result->CreateDataProperty(context,
+                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                         d->handle());
         }
         else return;
@@ -365,6 +366,7 @@ void Group::GetUnlimited(v8::Local<v8::String> property, const v8::PropertyCallb
 void Group::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int natts = 0;
@@ -387,8 +389,8 @@ void Group::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCall
             return;
         }
         auto *a = new Attribute(name.data(), NC_GLOBAL, obj->id);
-        result->Set(isolate->GetCurrentContext(),
-                    v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+        (void)result->CreateDataProperty(context,
+                    v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                     a->handle());
     }
     info.GetReturnValue().Set(result);
@@ -397,6 +399,7 @@ void Group::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCall
 void Group::GetSubgroups(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int ngrps = 0;
@@ -423,9 +426,8 @@ void Group::GetSubgroups(v8::Local<v8::String> property, const v8::PropertyCallb
         auto *g = new Group(grp_ids[i]);
         if (g->get_name(name.data()))
         {
-             // Suppress warning about unused return value
-             (void)result->Set(isolate->GetCurrentContext(),
-                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+             (void)result->CreateDataProperty(context,
+                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                         g->handle());
         }
         else
@@ -480,4 +482,75 @@ void Group::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object Group]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+void Group::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    const auto *obj = node::ObjectWrap::Unwrap<Group>(args.Holder());
+    
+    // Use internalized strings for better performance
+    v8::Local<v8::String> id_str = v8::String::NewFromUtf8Literal(isolate, "id");
+    v8::Local<v8::String> name_str = v8::String::NewFromUtf8Literal(isolate, "name");
+    v8::Local<v8::String> fullname_str = v8::String::NewFromUtf8Literal(isolate, "fullname");
+    v8::Local<v8::String> dimensions_str = v8::String::NewFromUtf8Literal(isolate, "dimensions");
+    v8::Local<v8::String> variables_str = v8::String::NewFromUtf8Literal(isolate, "variables");
+    v8::Local<v8::String> attributes_str = v8::String::NewFromUtf8Literal(isolate, "attributes");
+    v8::Local<v8::String> subgroups_str = v8::String::NewFromUtf8Literal(isolate, "subgroups");
+    
+    v8::Local<v8::Object> json = v8::Object::New(isolate);
+    
+    // Add id
+    (void)json->CreateDataProperty(context, id_str, v8::Integer::New(isolate, obj->id));
+    
+    // Add name
+    std::array<char, NC_MAX_NAME + 1> name{};
+    if (obj->get_name(name.data()))
+    {
+        (void)json->CreateDataProperty(context, name_str,
+                  v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked());
+    }
+    
+    // Add fullname
+    size_t len = 0;
+    int retval = nc_inq_grpname_len(obj->id, &len);
+    if (retval == NC_NOERR)
+    {
+        std::vector<char> fullname(len + 1, '\0');
+        retval = nc_inq_grpname_full(obj->id, nullptr, fullname.data());
+        if (retval == NC_NOERR)
+        {
+            (void)json->CreateDataProperty(context, fullname_str,
+                      v8::String::NewFromUtf8(isolate, fullname.data(), v8::NewStringType::kInternalized).ToLocalChecked());
+        }
+    }
+    
+    // Add dimensions, variables, attributes, subgroups
+    // These will be accessed through property getters which trigger the respective Get* methods
+    v8::Local<v8::Value> dimensions = args.Holder()->Get(context, dimensions_str).ToLocalChecked();
+    if (dimensions->IsObject())
+    {
+        (void)json->CreateDataProperty(context, dimensions_str, dimensions);
+    }
+    
+    v8::Local<v8::Value> variables = args.Holder()->Get(context, variables_str).ToLocalChecked();
+    if (variables->IsObject())
+    {
+        (void)json->CreateDataProperty(context, variables_str, variables);
+    }
+    
+    v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
+    if (attributes->IsObject())
+    {
+        (void)json->CreateDataProperty(context, attributes_str, attributes);
+    }
+    
+    v8::Local<v8::Value> subgroups = args.Holder()->Get(context, subgroups_str).ToLocalChecked();
+    if (subgroups->IsObject())
+    {
+        (void)json->CreateDataProperty(context, subgroups_str, subgroups);
+    }
+    
+    args.GetReturnValue().Set(json);
+}
 } // namespace nodenetcdfjs

package/src/Group.h

@@ -40,6 +40,7 @@ class Group : public node::ObjectWrap
     static void AddSubgroup(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void AddVariable(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     int id{-1};
 };

package/src/Variable.cpp

@@ -42,6 +42,7 @@ void Variable::Init(v8::Local<v8::Object> exports)
     NODE_SET_PROTOTYPE_METHOD(tpl, "writeStridedSlice", Variable::WriteStridedSlice);
     NODE_SET_PROTOTYPE_METHOD(tpl, "addAttribute", Variable::AddAttribute);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Variable::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", Variable::ToJSON);
     tpl->InstanceTemplate()->SetAccessor(
         v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal).ToLocalChecked(), Variable::GetId);
     tpl->InstanceTemplate()->SetAccessor(
@@ -678,6 +679,7 @@ void Variable::GetDimensions(v8::Local<v8::String> property, const v8::PropertyC
 void Variable::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(info.Holder());
     int natts;
     int retval = nc_inq_varnatts(obj->parent_id, obj->id, &natts);
@@ -697,8 +699,8 @@ void Variable::GetAttributes(v8::Local<v8::String> property, const v8::PropertyC
             return;
         }
         Attribute *a = new Attribute(name, obj->id, obj->parent_id);
-        result->Set(isolate->GetCurrentContext(),
-                    v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kNormal).ToLocalChecked(), a->handle());
+        (void)result->CreateDataProperty(context,
+                    v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized).ToLocalChecked(), a->handle());
     }
     info.GetReturnValue().Set(result);
 }
@@ -1349,4 +1351,52 @@ void Variable::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object Variable]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+void Variable::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    const auto *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    
+    // Use internalized strings for better performance
+    v8::Local<v8::String> id_str = v8::String::NewFromUtf8Literal(isolate, "id");
+    v8::Local<v8::String> name_str = v8::String::NewFromUtf8Literal(isolate, "name");
+    v8::Local<v8::String> type_str = v8::String::NewFromUtf8Literal(isolate, "type");
+    v8::Local<v8::String> dimensions_str = v8::String::NewFromUtf8Literal(isolate, "dimensions");
+    v8::Local<v8::String> attributes_str = v8::String::NewFromUtf8Literal(isolate, "attributes");
+    
+    v8::Local<v8::Object> json = v8::Object::New(isolate);
+    
+    // Add id
+    (void)json->CreateDataProperty(context, id_str, v8::Integer::New(isolate, obj->id));
+    
+    // Add name
+    char name[NC_MAX_NAME + 1];
+    if (obj->get_name(name))
+    {
+        (void)json->CreateDataProperty(context, name_str,
+                  v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized).ToLocalChecked());
+    }
+    
+    // Add type
+    const char *type_name = (obj->type < NC_BYTE || obj->type > NC_UINT) ? "unknown" : type_names[obj->type];
+    (void)json->CreateDataProperty(context, type_str,
+              v8::String::NewFromUtf8(isolate, type_name, v8::NewStringType::kInternalized).ToLocalChecked());
+    
+    // Add dimensions array with serialized dimension objects
+    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
+    v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
+    if (attributes->IsObject())
+    {
+        (void)json->CreateDataProperty(context, attributes_str, attributes);
+    }
+    
+    args.GetReturnValue().Set(json);
+}
 } // namespace nodenetcdfjs

package/src/Variable.h

@@ -68,6 +68,7 @@ class Variable : public node::ObjectWrap
     static void SetCompressionLevel(v8::Local<v8::String> property, v8::Local<v8::Value> val,
                                     const v8::PropertyCallbackInfo<void> &info);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static v8::Persistent<v8::Function> constructor;
 

package/test/attribute.js

@@ -33,4 +33,66 @@ describe('Attribute', function() {
             expect(attributes["name"].value).to.equal("air_pressure");
         });
     });
+
+    describe('toJSON', function() {
+        it('should serialize attribute without crashing', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            var attr = attributes["airport_dep"];
+            
+            // Explicitly call toJSON to test the V8 ToLocalChecked fix
+            var json = attr.toJSON();
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('name', 'airport_dep');
+            expect(json).to.have.property('value', 'FRA');
+        });
+
+        it('should handle variable attribute toJSON without crashing', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].variables["air_press"].attributes;
+            var attr = attributes["name"];
+            
+            // Explicitly call toJSON to test the V8 ToLocalChecked fix
+            var json = attr.toJSON();
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('name', 'name');
+            expect(json).to.have.property('value', 'air_pressure');
+        });
+
+        it('should work with JSON.stringify', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            var attr = attributes["airport_dep"];
+            
+            // Test that JSON.stringify (which calls toJSON internally) works
+            var jsonString = JSON.stringify(attr);
+            var json = JSON.parse(jsonString);
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('name', 'airport_dep');
+            expect(json).to.have.property('value', 'FRA');
+        });
+
+        it('should handle errors gracefully and return null value on type conversion errors', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            
+            // Iterate through all attributes to find any that might have type issues
+            // The toJSON method should handle these gracefully
+            for (var attrName in attributes) {
+                var attr = attributes[attrName];
+                
+                // This should not crash even if there are type conversion errors
+                var json = attr.toJSON();
+                
+                expect(json).to.be.an('object');
+                expect(json).to.have.property('name');
+                expect(json).to.have.property('value');
+                // Value should either be a valid value or null if there was an error
+                expect(json.value === null || typeof json.value !== 'undefined').to.be.true;
+            }
+        });
+    });
 });

package/test/json.js

@@ -0,0 +1,140 @@
+var expect = require("chai").expect,
+    nodenetcdf = require("../build/Release/nodenetcdf.node");
+
+describe('JSON Serialization', function() {
+    var file;
+    
+    beforeEach(function() {
+        file = new nodenetcdf.File("test/testrh.nc", "r");
+    });
+    
+    afterEach(function() {
+        file.close();
+    });
+    
+    describe('Dimension', function() {
+        it('should serialize dimension to JSON', function() {
+            var dim = file.root.dimensions['dim1'];
+            var json = JSON.parse(JSON.stringify(dim));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name', 'dim1');
+            expect(json).to.have.property('length', 10000);
+        });
+        
+        it('should have all required properties in JSON', function() {
+            var dim = file.root.dimensions['dim1'];
+            var json = JSON.parse(JSON.stringify(dim));
+            
+            expect(json.id).to.be.a('number');
+            expect(json.name).to.be.a('string');
+            expect(json.length).to.be.a('number');
+        });
+    });
+    
+    describe('Attribute', function() {
+        it('should serialize group attribute to JSON', function() {
+            var attributes = file.root.attributes;
+            for (var attrName in attributes) {
+                var attr = attributes[attrName];
+                var json = JSON.parse(JSON.stringify(attr));
+                
+                expect(json).to.be.an('object');
+                expect(json).to.have.property('name');
+                expect(json).to.have.property('value');
+                return; // Test first attribute
+            }
+        });
+        
+        it('should serialize variable attribute to JSON', function() {
+            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];
+                    var json = JSON.parse(JSON.stringify(attr));
+                    
+                    expect(json).to.be.an('object');
+                    expect(json).to.have.property('name');
+                    expect(json).to.have.property('value');
+                    return; // Test first attribute
+                }
+            }
+        });
+    });
+    
+    describe('Variable', function() {
+        it('should serialize variable to JSON', function() {
+            var variable = file.root.variables['var1'];
+            var json = JSON.parse(JSON.stringify(variable));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name', 'var1');
+            expect(json).to.have.property('type', 'double');
+        });
+        
+        it('should have all required properties in JSON', function() {
+            var variable = file.root.variables['var1'];
+            var json = JSON.parse(JSON.stringify(variable));
+            
+            expect(json.id).to.be.a('number');
+            expect(json.name).to.be.a('string');
+            expect(json.type).to.be.a('string');
+        });
+    });
+    
+    describe('Group', function() {
+        it('should serialize group to JSON', function() {
+            var group = file.root;
+            var json = JSON.parse(JSON.stringify(group));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name');
+            expect(json).to.have.property('fullname');
+        });
+        
+        it('should have all required properties in JSON', function() {
+            var group = file.root;
+            var json = JSON.parse(JSON.stringify(group));
+            
+            expect(json.id).to.be.a('number');
+            expect(json.name).to.be.a('string');
+            expect(json.fullname).to.be.a('string');
+        });
+        
+        it('should recursively serialize all children', function() {
+            var group = file.root;
+            var json = JSON.parse(JSON.stringify(group));
+            
+            expect(json).to.have.property('dimensions');
+            expect(json).to.have.property('variables');
+            expect(json).to.have.property('attributes');
+            expect(json).to.have.property('subgroups');
+        });
+    });
+    
+    describe('File', function() {
+        it('should serialize file to JSON', function() {
+            var json = JSON.parse(JSON.stringify(file));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name');
+            expect(json).to.have.property('fullname');
+        });
+        
+        it('should recursively serialize entire file structure', function() {
+            var json = JSON.parse(JSON.stringify(file));
+            
+            // File should serialize as root group with all children
+            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');
+        });
+    });
+});

package/test/typescript-test.ts

@@ -0,0 +1,87 @@
+// TypeScript test file to verify type definitions
+import { File, Group, Variable, Dimension, Attribute, FileMode, FileFormat, NetCDFDataType } from '../index';
+
+// Test file creation
+const file1 = new File('test.nc', 'c!', 'nodenetcdf');
+const file2 = new File('test2.nc', 'r');
+
+// Test root group access
+const root: Group = file1.root;
+
+// Test adding dimensions
+const timeDim: Dimension = root.addDimension('time', 0); // unlimited
+const latDim: Dimension = root.addDimension('lat', 180);
+const lonDim: Dimension = root.addDimension('lon', 360);
+
+// Test dimension properties
+const dimId: number = timeDim.id;
+const dimLength: number = latDim.length;
+let dimName: string = lonDim.name;
+dimName = 'longitude'; // should be settable
+lonDim.name = 'longitude';
+
+// Test adding variables
+const tempVar: Variable = root.addVariable('temperature', 'float', [timeDim, latDim, lonDim]);
+const presVar: Variable = root.addVariable('pressure', 'double', ['time', 'lat', 'lon']);
+
+// Test variable properties
+const varId: number = tempVar.id;
+const varType: NetCDFDataType = tempVar.type;
+const varDims: Dimension[] = tempVar.dimensions;
+const varAttrs: { [name: string]: Attribute } = tempVar.attributes;
+
+// Test variable settings
+tempVar.name = 'temp';
+tempVar.endianness = 'little';
+tempVar.checksumMode = 'fletcher32';
+tempVar.chunkMode = 'chunked';
+tempVar.chunkSizes = [1, 90, 180];
+tempVar.fillMode = 'fill';
+tempVar.fillValue = -999.0;
+tempVar.compressionShuffle = true;
+tempVar.compressionDeflate = true;
+tempVar.compressionLevel = 6;
+
+// Test reading and writing
+const data: any = tempVar.read();
+tempVar.write([1, 2, 3, 4, 5]);
+
+const sliceData: any = tempVar.readSlice([0, 0, 0], [1, 10, 10]);
+tempVar.writeSlice([0, 0, 0], [1, 10, 10], sliceData);
+
+const stridedData: any = tempVar.readStridedSlice([0, 0, 0], [1, 90, 180], [1, 2, 2]);
+tempVar.writeStridedSlice([0, 0, 0], [1, 90, 180], [1, 2, 2], stridedData);
+
+// Test attributes
+const attr1: Attribute = tempVar.addAttribute('units', 'string', 'degrees_C');
+const attr2: Attribute = root.addAttribute('title', 'string', 'Test NetCDF File');
+
+const attrName: string = attr1.name;
+const attrValue: any = attr1.value;
+attr1.name = 'unit';
+attr1.value = 'Celsius';
+attr1.delete();
+
+// Test subgroups
+const subgroup: Group = root.addSubgroup('forecast');
+const subgroupId: number = subgroup.id;
+const subgroupVars: { [name: string]: Variable } = subgroup.variables;
+const subgroupDims: { [name: string]: Dimension } = subgroup.dimensions;
+const subgroupAttrs: { [name: string]: Attribute } = subgroup.attributes;
+const subgroupSubgroups: { [name: string]: Group } = subgroup.subgroups;
+const subgroupName: string = subgroup.name;
+const subgroupFullname: string = subgroup.fullname;
+const unlimitedDim: Dimension | null = subgroup.unlimited;
+
+// Test file operations
+file1.sync();
+file1.close();
+
+// Test inspect methods
+const fileInspect: string = file1.inspect();
+const groupInspect: string = root.inspect();
+const varInspect: string = tempVar.inspect();
+const dimInspect: string = timeDim.inspect();
+const attrInspect: string = attr2.inspect();
+
+console.log('TypeScript type checking passed!');