nodenetcdf 4.9.3

package/scripts/setup-vcpkg.js

@@ -0,0 +1,93 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Allow users to skip vcpkg setup if they prefer system libraries
+if (process.env.SKIP_VCPKG_SETUP === '1') {
+  console.log('SKIP_VCPKG_SETUP is set, skipping vcpkg setup');
+  console.log('Make sure NetCDF libraries are installed on your system');
+  process.exit(0);
+}
+
+const platform = os.platform();
+
+console.log('Setting up vcpkg and NetCDF dependencies...');
+
+// Determine vcpkg triplet based on platform
+let triplet;
+if (platform === 'win32') {
+  triplet = 'x64-windows';
+} else if (platform === 'linux') {
+  triplet = 'x64-linux';
+} else if (platform === 'darwin') {
+  triplet = 'arm64-osx';
+} else {
+  console.error(`Unsupported platform: ${platform}`);
+  process.exit(1);
+}
+
+function runCommand(cmd, options = {}) {
+  console.log(`Running: ${cmd}`);
+  try {
+    execSync(cmd, { 
+      stdio: 'inherit',
+      ...options
+    });
+  } catch (error) {
+    console.error(`Failed to run command: ${cmd}`);
+    throw error;
+  }
+}
+
+// Check if vcpkg directory exists
+if (!fs.existsSync('vcpkg')) {
+  console.log('vcpkg not found, cloning repository...');
+  runCommand('git clone https://github.com/microsoft/vcpkg.git');
+} else {
+  console.log('vcpkg directory already exists');
+}
+
+// Bootstrap vcpkg
+const vcpkgExecutable = platform === 'win32' ? 'vcpkg.exe' : 'vcpkg';
+const vcpkgPath = path.join('vcpkg', vcpkgExecutable);
+
+if (!fs.existsSync(vcpkgPath)) {
+  console.log('Bootstrapping vcpkg...');
+  if (platform === 'win32') {
+    runCommand('.\\vcpkg\\bootstrap-vcpkg.bat', { shell: true });
+  } else {
+    runCommand('./vcpkg/bootstrap-vcpkg.sh', { shell: true });
+  }
+} else {
+  console.log('vcpkg already bootstrapped');
+}
+
+// Install nodenetcdf using vcpkg
+console.log(`Installing netcdf-c for ${triplet}...`);
+try {
+  runCommand(`${vcpkgPath} install netcdf-c:${triplet}`);
+  console.log('NetCDF dependencies installed successfully!');
+} catch (error) {
+  console.error('Failed to install netcdf-c');
+  console.error('You may need to install build tools for your platform:');
+  console.error('- Windows: Visual Studio Build Tools');
+  console.error('- Linux: build-essential, cmake');
+  console.error('- macOS: Xcode Command Line Tools');
+  process.exit(1);
+}
+
+console.log('vcpkg setup complete!');
+
+// Verify that netcdf.h is actually available
+const vcpkgInstalledDir = path.join('vcpkg', 'installed', triplet);
+const includeDir = path.join(vcpkgInstalledDir, 'include');
+const netcdfHeader = path.join(includeDir, 'netcdf.h');
+
+if (fs.existsSync(netcdfHeader)) {
+  console.log(`✓ Verified netcdf.h exists at: ${netcdfHeader}`);
+} else {
+  console.error(`✗ ERROR: netcdf.h not found at: ${netcdfHeader}`);
+  console.error('vcpkg installation may have failed or be incomplete');
+  process.exit(1);
+}

package/scripts/verify-build-deps.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Determine the platform-specific vcpkg directory
+const platform = os.platform();
+let triplet;
+
+if (platform === 'win32') {
+  triplet = 'x64-windows';
+} else if (platform === 'linux') {
+  triplet = 'x64-linux';
+} else if (platform === 'darwin') {
+  triplet = 'arm64-osx';
+} else {
+  console.error(`Unsupported platform: ${platform}`);
+  process.exit(1);
+}
+
+console.log('Verifying build dependencies...');
+
+// Check if vcpkg installed directory exists
+const vcpkgInstalledDir = path.join('vcpkg', 'installed', triplet);
+if (!fs.existsSync(vcpkgInstalledDir)) {
+  console.error(`✗ ERROR: vcpkg installation directory not found: ${vcpkgInstalledDir}`);
+  console.error('Please run: npm run preinstall');
+  process.exit(1);
+}
+
+// Verify netcdf.h exists
+const includeDir = path.join(vcpkgInstalledDir, 'include');
+const netcdfHeader = path.join(includeDir, 'netcdf.h');
+
+if (!fs.existsSync(netcdfHeader)) {
+  console.error(`✗ ERROR: netcdf.h not found at: ${netcdfHeader}`);
+  console.error('vcpkg installation may be incomplete');
+  console.error('Please run: npm run preinstall');
+  process.exit(1);
+}
+
+console.log(`✓ Found netcdf.h at: ${netcdfHeader}`);
+
+// Verify library files exist
+const libDir = path.join(vcpkgInstalledDir, 'lib');
+let requiredLib;
+
+if (platform === 'win32') {
+  requiredLib = path.join(libDir, 'netcdf.lib');
+} else {
+  requiredLib = path.join(libDir, 'libnetcdf.a');
+}
+
+if (!fs.existsSync(requiredLib)) {
+  console.error(`✗ ERROR: NetCDF library not found at: ${requiredLib}`);
+  console.error('vcpkg installation may be incomplete');
+  console.error('Please run: npm run preinstall');
+  process.exit(1);
+}
+
+console.log(`✓ Found NetCDF library at: ${requiredLib}`);
+console.log(`✓ Build dependencies verified for ${triplet}`);

package/src/Attribute.cpp

@@ -0,0 +1,334 @@
+#include "Attribute.h"
+#include "nodenetcdfjs.h"
+#include <inttypes.h>
+#include <iostream>
+#include <netcdf.h>
+
+
+namespace nodenetcdfjs
+{
+
+v8::Persistent<v8::Function> Attribute::constructor;
+
+Attribute::Attribute(const char *name_, int var_id_, int parent_id_) noexcept
+    : name(name_)
+    , var_id(var_id_)
+    , parent_id(parent_id_)
+{
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    v8::Local<v8::Object> obj =
+        v8::Local<v8::Function>::New(isolate, constructor)->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+    Wrap(obj);
+    const int retval = nc_inq_atttype(parent_id, var_id_, name_, &type);
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(isolate, retval);
+    }
+}
+
+Attribute::Attribute(const char *name_, int var_id_, int parent_id_, int type_) noexcept
+    : name(name_)
+    , var_id(var_id_)
+    , parent_id(parent_id_)
+    , type(type_)
+{
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    v8::Local<v8::Object> obj =
+        v8::Local<v8::Function>::New(isolate, constructor)->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+    Wrap(obj);
+}
+
+void Attribute::Init(v8::Local<v8::Object> exports)
+{
+    v8::Isolate *isolate = exports->GetIsolate();
+    v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(isolate);
+    tpl->SetClassName(v8::String::NewFromUtf8(isolate, "Attribute", v8::NewStringType::kNormal).ToLocalChecked());
+    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "delete", Attribute::Delete);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Attribute::Inspect);
+    tpl->InstanceTemplate()->SetAccessor(
+        v8::String::NewFromUtf8(isolate, "name", v8::NewStringType::kNormal).ToLocalChecked(), Attribute::GetName,
+        Attribute::SetName);
+    tpl->InstanceTemplate()->SetAccessor(
+        v8::String::NewFromUtf8(isolate, "value", v8::NewStringType::kNormal).ToLocalChecked(), Attribute::GetValue,
+        Attribute::SetValue);
+    constructor.Reset(isolate, tpl->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
+}
+
+void Attribute::GetName(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
+{
+    v8::Isolate *isolate = info.GetIsolate();
+    const auto *obj = node::ObjectWrap::Unwrap<Attribute>(info.Holder());
+    info.GetReturnValue().Set(
+        v8::String::NewFromUtf8(isolate, obj->name.c_str(), v8::NewStringType::kNormal).ToLocalChecked());
+}
+
+void Attribute::SetName(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                        const v8::PropertyCallbackInfo<void> &info)
+{
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    auto *obj = node::ObjectWrap::Unwrap<Attribute>(info.Holder());
+
+    const v8::String::Utf8Value new_name_(isolate, val->ToString(isolate->GetCurrentContext()).ToLocalChecked());
+    const int retval = nc_rename_att(obj->parent_id, obj->var_id, obj->name.c_str(), *new_name_);
+
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(isolate, retval);
+        return;
+    }
+    obj->name = *new_name_;
+}
+
+void Attribute::GetValue(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
+{
+    v8::Isolate *isolate = info.GetIsolate();
+    const auto *obj = node::ObjectWrap::Unwrap<Attribute>(info.Holder());
+
+    if ((obj->type < NC_BYTE || obj->type > NC_UINT64) && obj->type != NC_STRING)
+    {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+                .ToLocalChecked()));
+        return;
+    }
+
+    size_t len = 0;
+    int retval = nc_inq_attlen(obj->parent_id, obj->var_id, obj->name.c_str(), &len);
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(isolate, retval);
+        return;
+    }
+
+    switch (obj->type)
+    {
+    case NC_BYTE: {
+        std::vector<int8_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::New(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(int8_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(int8_t));
+            info.GetReturnValue().Set(v8::Int8Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_SHORT: {
+        std::vector<int16_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::New(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(int16_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(int16_t));
+            info.GetReturnValue().Set(v8::Int16Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_INT: {
+        std::vector<int32_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::New(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(int32_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(int32_t));
+            info.GetReturnValue().Set(v8::Int32Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_FLOAT: {
+        std::vector<float> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Number::New(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(float));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(float));
+            info.GetReturnValue().Set(v8::Float32Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_DOUBLE: {
+        std::vector<double> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Number::New(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(double));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(double));
+            info.GetReturnValue().Set(v8::Float64Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_UBYTE: {
+        std::vector<uint8_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::New(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(uint8_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(uint8_t));
+            info.GetReturnValue().Set(v8::Uint8Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_USHORT: {
+        std::vector<uint16_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::New(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(uint16_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(uint16_t));
+            info.GetReturnValue().Set(v8::Uint16Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_UINT: {
+        std::vector<uint32_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::NewFromUnsigned(isolate, v[0]));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(uint32_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(uint32_t));
+            info.GetReturnValue().Set(v8::Uint32Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_INT64: {
+        std::vector<int64_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::New(isolate, static_cast<int32_t>(v[0])));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(int64_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(int64_t));
+            info.GetReturnValue().Set(v8::Int32Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_UINT64: {
+        std::vector<uint64_t> v(len);
+        retval = nc_get_att(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        if (len == 1)
+        {
+            info.GetReturnValue().Set(v8::Integer::NewFromUnsigned(isolate, static_cast<uint32_t>(v[0])));
+        }
+        else
+        {
+            v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, len * sizeof(uint64_t));
+            memcpy(buffer->GetBackingStore()->Data(), v.data(), len * sizeof(uint64_t));
+            info.GetReturnValue().Set(v8::Uint32Array::New(buffer, 0, len));
+        }
+    }
+    break;
+    case NC_CHAR:
+    case NC_STRING: {
+        std::vector<char> v(len + 1, '\0');
+        retval = nc_get_att_text(obj->parent_id, obj->var_id, obj->name.c_str(), v.data());
+        info.GetReturnValue().Set(
+            v8::String::NewFromUtf8(isolate, v.data(), v8::NewStringType::kNormal).ToLocalChecked());
+    }
+    break;
+    }
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(isolate, retval);
+    }
+}
+
+void Attribute::SetValue(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                         const v8::PropertyCallbackInfo<void> &info)
+{
+    auto *obj = node::ObjectWrap::Unwrap<Attribute>(info.Holder());
+    obj->set_value(val);
+}
+
+void Attribute::set_value(const v8::Local<v8::Value> &val)
+{
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    if ((type < NC_BYTE || type > NC_UINT) && type != NC_STRING)
+    {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+                .ToLocalChecked()));
+        return;
+    }
+
+    int retval = NC_NOERR;
+    if (val->IsUint32())
+    {
+        const uint32_t v = val->Uint32Value(isolate->GetCurrentContext()).ToChecked();
+        retval = nc_put_att(parent_id, var_id, name.c_str(), NC_UINT, 1, &v);
+    }
+    else if (val->IsInt32())
+    {
+        const int32_t v = val->Int32Value(isolate->GetCurrentContext()).ToChecked();
+        retval = nc_put_att(parent_id, var_id, name.c_str(), NC_INT, 1, &v);
+    }
+    else if (val->IsNumber())
+    {
+        const double v = val->NumberValue(isolate->GetCurrentContext()).ToChecked();
+        retval = nc_put_att(parent_id, var_id, name.c_str(), NC_DOUBLE, 1, &v);
+    }
+    else
+    {
+        const std::string v =
+            *v8::String::Utf8Value(isolate, val->ToString(isolate->GetCurrentContext()).ToLocalChecked());
+        retval = nc_put_att_text(parent_id, var_id, name.c_str(), v.length(), v.c_str());
+    }
+
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(isolate, retval);
+    }
+}
+
+void Attribute::Delete(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    auto *obj = node::ObjectWrap::Unwrap<Attribute>(args.Holder());
+    const int retval = nc_del_att(obj->parent_id, obj->var_id, obj->name.c_str());
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(args.GetIsolate(), retval);
+    }
+}
+
+void Attribute::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    args.GetReturnValue().Set(
+        v8::String::NewFromUtf8(isolate, "[object Attribute]", v8::NewStringType::kNormal).ToLocalChecked());
+}
+} // namespace nodenetcdfjs

package/src/Attribute.h

@@ -0,0 +1,46 @@
+#ifndef NODENETCDFJS_ATTRIBUTE_H
+#define NODENETCDFJS_ATTRIBUTE_H
+
+#include <node.h>
+#include <node_object_wrap.h>
+#include <string>
+
+namespace nodenetcdfjs
+{
+
+class Attribute : public node::ObjectWrap
+{
+  public:
+    static void Init(v8::Local<v8::Object> exports);
+    Attribute(const char *name_, int var_id_, int parent_id_) noexcept;
+    Attribute(const char *name_, int var_id_, int parent_id_, int type_) noexcept;
+
+    void set_value(const v8::Local<v8::Value> &val);
+
+  private:
+    // Delete copy and move operations for safety
+    Attribute(const Attribute &) = delete;
+    Attribute &operator=(const Attribute &) = delete;
+    Attribute(Attribute &&) = delete;
+    Attribute &operator=(Attribute &&) = delete;
+
+    static v8::Persistent<v8::Function> constructor;
+
+    static void Delete(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void GetName(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetName(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                        const v8::PropertyCallbackInfo<void> &info);
+    static void GetValue(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetValue(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                         const v8::PropertyCallbackInfo<void> &info);
+    static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    std::string name{};
+    int var_id{-1};
+    int parent_id{-1};
+    int type{-1};
+};
+
+} // namespace nodenetcdfjs
+
+#endif

package/src/Dimension.cpp

@@ -0,0 +1,105 @@
+#include "Dimension.h"
+#include "nodenetcdfjs.h"
+#include <netcdf.h>
+
+
+namespace nodenetcdfjs
+{
+
+v8::Persistent<v8::Function> Dimension::constructor;
+
+Dimension::Dimension(int id_, int parent_id_) noexcept
+    : id(id_)
+    , parent_id(parent_id_)
+{
+    v8::Isolate *isolate = v8::Isolate::GetCurrent();
+    v8::Local<v8::Object> obj =
+        v8::Local<v8::Function>::New(isolate, constructor)->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+    Wrap(obj);
+}
+
+void Dimension::Init(v8::Local<v8::Object> exports)
+{
+    v8::Isolate *isolate = exports->GetIsolate();
+    v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(isolate);
+    tpl->SetClassName(v8::String::NewFromUtf8(isolate, "Dimension", v8::NewStringType::kNormal).ToLocalChecked());
+    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Dimension::Inspect);
+    tpl->InstanceTemplate()->SetAccessor(
+        v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal).ToLocalChecked(), Dimension::GetId);
+    tpl->InstanceTemplate()->SetAccessor(
+        v8::String::NewFromUtf8(isolate, "length", v8::NewStringType::kNormal).ToLocalChecked(), Dimension::GetLength);
+    tpl->InstanceTemplate()->SetAccessor(
+        v8::String::NewFromUtf8(isolate, "name", v8::NewStringType::kNormal).ToLocalChecked(), Dimension::GetName,
+        Dimension::SetName);
+    constructor.Reset(isolate, tpl->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
+}
+
+bool Dimension::get_name(char *name) const noexcept
+{
+    const int retval = nc_inq_dimname(parent_id, id, name);
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(v8::Isolate::GetCurrent(), retval);
+        return false;
+    }
+    return true;
+}
+
+void Dimension::GetId(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
+{
+    v8::Isolate *isolate = info.GetIsolate();
+    const auto *obj = node::ObjectWrap::Unwrap<Dimension>(info.Holder());
+    info.GetReturnValue().Set(v8::Integer::New(isolate, obj->id));
+}
+
+void Dimension::GetLength(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
+{
+    v8::Isolate *isolate = info.GetIsolate();
+    const auto *obj = node::ObjectWrap::Unwrap<Dimension>(info.Holder());
+
+    size_t len = 0;
+    const int retval = nc_inq_dimlen(obj->parent_id, obj->id, &len);
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(isolate, retval);
+        return;
+    }
+    info.GetReturnValue().Set(v8::Integer::New(isolate, static_cast<int32_t>(len)));
+}
+
+void Dimension::GetName(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
+{
+    v8::Isolate *isolate = info.GetIsolate();
+    const auto *obj = node::ObjectWrap::Unwrap<Dimension>(info.Holder());
+
+    std::array<char, NC_MAX_NAME + 1> name{};
+    if (obj->get_name(name.data()))
+    {
+        info.GetReturnValue().Set(
+            v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked());
+    }
+}
+
+void Dimension::SetName(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                        const v8::PropertyCallbackInfo<void> &info)
+{
+    v8::Isolate *isolate = info.GetIsolate();
+    auto *obj = node::ObjectWrap::Unwrap<Dimension>(info.Holder());
+
+    const v8::String::Utf8Value new_name_(isolate, val->ToString(isolate->GetCurrentContext()).ToLocalChecked());
+    const int retval = nc_rename_dim(obj->parent_id, obj->id, *new_name_);
+
+    if (retval != NC_NOERR)
+    {
+        throw_netcdf_error(isolate, retval);
+    }
+}
+
+void Dimension::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    args.GetReturnValue().Set(
+        v8::String::NewFromUtf8(isolate, "[object Dimension]", v8::NewStringType::kNormal).ToLocalChecked());
+}
+} // namespace nodenetcdfjs

package/src/Dimension.h

@@ -0,0 +1,40 @@
+#ifndef NODENETCDFJS_DIMENSION_H
+#define NODENETCDFJS_DIMENSION_H
+
+#include <node.h>
+#include <node_object_wrap.h>
+
+namespace nodenetcdfjs
+{
+
+class Dimension : public node::ObjectWrap
+{
+  public:
+    static void Init(v8::Local<v8::Object> exports);
+    Dimension(int id_, int parent_id_) noexcept;
+
+    [[nodiscard]] bool get_name(char *name) const noexcept;
+
+  private:
+    // Delete copy and move operations for safety
+    Dimension(const Dimension &) = delete;
+    Dimension &operator=(const Dimension &) = delete;
+    Dimension(Dimension &&) = delete;
+    Dimension &operator=(Dimension &&) = delete;
+
+    static v8::Persistent<v8::Function> constructor;
+
+    static void GetId(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void GetLength(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void GetName(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    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);
+
+    int id{-1};
+    int parent_id{-1};
+};
+
+} // namespace nodenetcdfjs
+
+#endif