feat: use type name as class name

Author: typesafe

src/Node.zig

@@ -39,7 +39,7 @@ pub const NodeContext = struct {
         const lifetime = getLifetimeHandler(T);
         const props = getProps(T);
         var class: c.napi_value = undefined;
-        s2e(c.napi_define_class(self.napi_env, "Foo", 3, lifetime.init, null, props.len, props.ptr, &class)) catch unreachable;
+        s2e(c.napi_define_class(self.napi_env, @typeName(T), @typeName(T).len, lifetime.init, null, props.len, props.ptr, &class)) catch unreachable;
 
         return NodeValue.init(self.napi_env, class);
     }
@@ -168,14 +168,18 @@ pub const NodeContext = struct {
             pub fn init(env: c.napi_env, cb: c.napi_callback_info) callconv(.c) c.napi_value {
                 std.log.info("init {any} {any} {any}", .{ env, cb, T });
 
-                const init_fn = @field(T, "init");
-
                 var new_target: c.napi_value = null;
                 if (c.napi_get_new_target(env, cb, &new_target) != c.napi_ok or new_target == null) {
                     _ = c.napi_throw_error(env, null, "Constructor must be called with `new`.");
                     return null;
                 }
 
+                // TODO: if no init, use args object to set fields
+                // TODO: if no fields -> treat as namespace
+                // if (@hasField(T, "init")) {}
+
+                const init_fn = @field(T, "init");
+
                 const params = @typeInfo(@TypeOf(init_fn)).@"fn".params;
 
                 const node = NodeContext{ .napi_env = env };
@@ -254,7 +258,7 @@ pub const NodeContext = struct {
                     const self: *T = @ptrCast(@alignCast(data.?));
                     std.log.info(" Finalizer data {any} {any}", .{ data, self });
                     freee(T, self);
-                    registry.wrapped_instances.remove(@intFromPtr(self));
+                    registry.untrack(self);
                 }
             }
 

tests/zig_modules/export-class/index.spec.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "bun:test";
+
+import requireTestModule from "../";
+const TestClass = requireTestModule("export-class");
+
+describe("node_api.register(type)", () => {
+  it("should return class", () => {
+    expect(typeof TestClass).toEqual("function");
+    expect(TestClass.name).toEqual("TestClass");
+    expect(TestClass.toString()).toEqual(
+      "function TestClass() {\n    [native code]\n}"
+    );
+  });
+
+  it("should define static memethods", () => {
+    expect(typeof TestClass.static).toEqual("function");
+    expect(typeof TestClass.static).toEqual("function");
+    expect(TestClass.static()).toEqual("static");
+  });
+
+  it("should be constructable", () => {
+    expect(new TestClass()).toEqual({});
+  });
+
+  it("should have methods", () => {
+    const instance = new TestClass();
+    expect(typeof instance.method).toEqual("function");
+    expect(instance.method()).toEqual("method");
+  });
+});

tests/zig_modules/export-class/src/TestClass.zig

@@ -0,0 +1,13 @@
+pub fn init() @This() {
+    return .{};
+}
+
+pub fn deinit(_: @This()) !void {}
+
+pub fn method(_: @This()) ![]const u8 {
+    return "method";
+}
+
+pub fn static() ![]const u8 {
+    return "static";
+}

tests/zig_modules/export-class/src/root.zig

@@ -0,0 +1,6 @@
+const node_api = @import("node-api");
+const TestClass = @import("TestClass.zig");
+
+comptime {
+    node_api.@"export"(TestClass);
+}