feat: Complete binding function

Author: jinzhongjia

examples/call_zig_from_js/main.zig

@@ -14,7 +14,9 @@ pub fn main() !void {
     // _ = try nwin.bind("my_function_integer", my_function_integer);
     _ = try nwin.bind("my_function_boolean", my_function_boolean);
     _ = try nwin.bind("my_function_with_response", my_function_with_response);
-    _ = try nwin.bind("my_function_raw_binary", my_function_raw_binary);
+    // _ = try nwin.binding("my_function_raw_binary", my_function_raw_binary);
+    _ = try nwin.binding("my_function_raw_binary", raw_binary);
+    // _ = try nwin.bind("my_function_raw_binary", my_function_raw_binary);
 
     try nwin.show(html);
 
@@ -104,6 +106,33 @@ fn my_function_with_response(e: *webui.Event) void {
     e.returnValue(res);
 }
 
+fn raw_binary(e: *webui.Event, raw_1: [:0]const u8, raw_2: [*]const u8) void {
+    // Or e.getSizeAt(0);
+    const len_1 = e.getSize() catch return;
+    const len_2 = e.getSizeAt(1) catch return;
+
+    // Print raw_1
+    std.debug.print("my_function_raw_binary 1 ({} bytes): ", .{len_1});
+    for (0..len_1) |i| {
+        std.debug.print("0x{x} ", .{raw_1[i]});
+    }
+    std.debug.print("\n", .{});
+
+    // Check raw_2 (Big)
+    // [0xA1, 0x00..., 0xA2]
+    var vaild = false;
+
+    if (raw_2[0] == 0xA1 and raw_2[len_2 - 1] == 0xA2) {
+        vaild = true;
+    }
+
+    // Print raw_2
+    std.debug.print("my_function_raw_binary 2 big ({} bytes): valid data? {s}\n", .{
+        len_2,
+        if (vaild) "Yes" else "No",
+    });
+}
+
 fn my_function_raw_binary(e: *webui.Event) void {
     // JavaScript:
     // my_function_raw_binary(new Uint8Array([0x41]), new Uint8Array([0x42, 0x43]));

src/webui.zig

@@ -778,53 +778,56 @@ pub fn binding(self: webui, element: [:0]const u8, comptime callback: anytype) !
         fn handle(e: *Event) void {
             var param_tup: tup_t = undefined;
 
+            var index: usize = 0;
             inline for (fnInfo.params, 0..fnInfo.params.len) |param, i| {
                 if (param.type) |tt| {
                     const paramTInfo = @typeInfo(tt);
                     switch (paramTInfo) {
                         .@"struct" => {
-                            if (tt != Event) {
+                            if (tt == Event) {
+                                param_tup[i] = e.*;
+                                index += 1;
+                            } else {
                                 const err_msg = std.fmt.comptimePrint(
                                     "the struct type is ({}), the struct type you can use only is Event in params!",
                                     .{tt},
                                 );
                                 @compileError(err_msg);
                             }
-                            param_tup[i] = e;
                         },
                         .bool => {
-                            const res = e.getBoolAt(i);
+                            const res = e.getBoolAt(i - index);
                             param_tup[i] = res;
                         },
                         .int => {
-                            const res = e.getIntAt(i);
+                            const res = e.getIntAt(i - index);
                             param_tup[i] = @intCast(res);
                         },
                         .float => {
-                            const res = e.getFloatAt(i);
+                            const res = e.getFloatAt(i - index);
                             param_tup[i] = res;
                         },
                         .pointer => |pointer| {
-                            if (pointer.size != .slice or pointer.child != u8 or pointer.is_const == false) {
+                            if (pointer.size == .slice and pointer.child == u8 and pointer.is_const == true) {
+                                if (pointer.sentinel()) |sentinel| {
+                                    if (sentinel == 0) {
+                                        const str_ptr = e.getStringAt(i - index);
+                                        param_tup[i] = str_ptr;
+                                    }
+                                }
+                            } else if (pointer.size == .one and pointer.child == Event) {
+                                param_tup[i] = e;
+                                index += 1;
+                            } else if (pointer.size == .many and pointer.child == u8 and pointer.is_const == true and pointer.sentinel() == null) {
+                                const raw_ptr = e.getRawAt(i - index);
+                                param_tup[i] = raw_ptr;
+                            } else {
                                 const err_msg = std.fmt.comptimePrint(
-                                    "the pointer type is ({}), not support other type for pointer param!",
+                                    "the pointer type is ({}), now we only support [:0]const u8 or [*]const u8 or *webui.Event !",
                                     .{tt},
                                 );
                                 @compileError(err_msg);
                             }
-                            if (pointer.sentinel()) |sentinel| {
-                                if (sentinel != 0) {
-                                    const err_msg = std.fmt.comptimePrint(
-                                        "type is ({}), only support these types: Event, Bool, Int, Float, [:0]const u8, []u8!",
-                                        .{tt},
-                                    );
-                                    @compileError(err_msg);
-                                }
-                                const str_ptr = e.getStringAt(i);
-                                param_tup[i] = str_ptr;
-                            } else {
-                                @compileError("not support []u8");
-                            }
                         },
                         else => {
                             const err_msg = std.fmt.comptimePrint(