feat: add NodeArray

Author: typesafe

src/node_values.zig

@@ -192,6 +192,41 @@ pub const NodeObject = struct {
     }
 };
 
+pub const NodeArray = struct {
+    const Self = @This();
+
+    napi_env: c.napi_env,
+    napi_value: c.napi_value,
+
+    pub fn asValue(self: NodeArray.Self) !NodeValue {
+        return NodeValue{
+            .napi_env = self.napi_env,
+            .napi_value = self.napi_value,
+        };
+    }
+
+    pub fn len(self: NodeArray.Self) !u32 {
+        var v: u32 = undefined;
+        try s2e(c.napi_get_array_length(self.napi_env, self.napi_value, &v));
+        return v;
+    }
+
+    /// Gets a NodeValue indicating wether the object has a property with the specified name.
+    pub fn get(self: NodeArray.Self, index: u32) !NodeValue {
+        var v: c.napi_value = undefined;
+        try s2e(c.napi_get_element(self.napi_env, self.napi_value, index, &v));
+        return NodeValue{ .napi_env = self.napi_env, .napi_value = v };
+    }
+
+    /// Set the specified NodeValue at the specified index of the NodeArray.
+    pub fn set(self: NodeArray.Self, index: u32, value: NodeValue) !NodeValue {
+        try s2e(c.napi_set_element(self.napi_env, self.napi_value, index, value.napi_value));
+        return value;
+    }
+
+    // get/set [], push, splice, etc.
+};
+
 /// Represents a JS function.
 pub fn NodeFunction(comptime F: anytype) type {
     const f = switch (@typeInfo(F)) {
@@ -234,24 +269,3 @@ fn TupleTypeOf(params: []const std.builtin.Type.Fn.Param) type {
 
     return std.meta.Tuple(&argTypes);
 }
-pub const NodeArray = struct {
-    const Self = @This();
-
-    napi_env: c.napi_env,
-    napi_value: c.napi_value,
-
-    fn len(self: NodeValue.Self) !u32 {
-        var v: u32 = undefined;
-        s2e(c.napi_get_array_length(self.napi_env, self.napi_value, &v));
-        return v;
-    }
-
-    pub fn asValue(self: NodeArray.Self) !NodeValue {
-        return NodeValue{
-            .napi_env = self.napi_env,
-            .napi_value = self.napi_value,
-        };
-    }
-
-    // get/set [], push, splice, etc.
-};

tests/node-array.spec.ts

@@ -0,0 +1,35 @@
+import addon from "node-api-test-module";
+import { describe, it, expect } from "bun:test";
+
+describe("NodeArray", () => {
+  describe("len", () => {
+    it("should return zero for empty array ", () => {
+      expect(addon.nodeArray.len([])).toEqual(0);
+    });
+    it("should return length of non-emtpy array ", () => {
+      expect(addon.nodeArray.len([123, 123, 123])).toEqual(3);
+    });
+  });
+
+  describe("get", () => {
+    it("should get value of index", () => {
+      expect(addon.nodeArray.get([123, 456], 1)).toEqual(456);
+    });
+    it("should get undefined for invalid index ", () => {
+      expect(addon.nodeArray.get([], 1)).toEqual(undefined);
+    });
+  });
+
+  describe("set", () => {
+    it("should set value at index", () => {
+      const arr = [1, 2, 3] as any[];
+      expect(addon.nodeArray.set(arr, 1, "foo")).toEqual("foo");
+      expect(arr).toEqual([1, "foo", 3]);
+    });
+    it("should set value at index past len", () => {
+      const arr = [1, 2, 3] as any[];
+      expect(addon.nodeArray.set(arr, 5, "foo")).toEqual("foo");
+      expect(arr).toEqual([1, 2, 3, undefined, undefined, "foo"]);
+    });
+  });
+});

tests/zig/node_values/NodeArrayTests.zig

@@ -0,0 +1,26 @@
+const std = @import("std");
+const node_api = @import("node-api");
+
+const NodeContext = node_api.NodeContext;
+const NodeValue = node_api.NodeValue;
+const NodeObject = node_api.NodeObject;
+const NodeArray = node_api.NodeArray;
+
+pub fn init() @This() {
+    return @This(){};
+}
+
+// TODO: make this optional
+pub fn deinit() !void {}
+
+pub fn len(arr: NodeArray) !u32 {
+    return try arr.len();
+}
+
+pub fn get(arr: NodeArray, index: u32) !NodeValue {
+    return try arr.get(index);
+}
+
+pub fn set(arr: NodeArray, index: u32, v: NodeValue) !NodeValue {
+    return try arr.set(index, v);
+}

tests/zig/test-module.zig

@@ -3,6 +3,7 @@ const node_api = @import("node-api");
 
 const TestClass = @import("TestClass.zig");
 const NodeObjectTests = @import("node_values/NodeObjectTests.zig");
+const NodeArrayTests = @import("node_values/NodeArrayTests.zig");
 const WrapTarget = @import("WrapTarget.zig");
 const Serialization = @import("Serialization.zig");
 
@@ -16,6 +17,7 @@ fn init(node: node_api.NodeContext) !?node_api.NodeValue {
 
     return try node.serialize(.{
         .nodeObject = NodeObjectTests,
+        .nodeArray = NodeArrayTests,
         .serialization = Serialization,
         .TestClass = TestClass,
         .wrappedInstance = try node.wrapInstance(WrapTarget, .{ .foo = 123, .bar = "hopla" }),