Merge pull request #1213 from lightpanda-io/nikneym/remove-kludge

src/browser/js/Context.zig

@@ -780,41 +780,39 @@ pub fn jsValueToZig(self: *Context, comptime named_function: NamedFunction, comp
 // Extracted so that it can be used in both jsValueToZig and in
 // probeJsValueToZig. Avoids having to duplicate this logic when probing.
 fn jsValueToStruct(self: *Context, comptime named_function: NamedFunction, comptime T: type, js_value: v8.Value) !?T {
-    if (T == js.Function) {
+    return switch (T) {
+        js.Function => {
             if (!js_value.isFunction()) {
                 return null;
             }
+
             return try self.createFunction(js_value);
-    }
-
-    if (@hasDecl(T, "_TYPED_ARRAY_ID_KLUDGE")) {
-        const VT = @typeInfo(std.meta.fieldInfo(T, .values).type).pointer.child;
-        const arr = (try self.jsValueToTypedArray(VT, js_value)) orelse return null;
-        return .{ .values = arr };
-    }
-
-    if (T == js.String) {
-        return .{ .string = try self.valueToString(js_value, .{ .allocator = self.arena }) };
-    }
-
-    const js_obj = js_value.castTo(v8.Object);
-
-    if (comptime T == js.Object) {
+        },
+        // zig fmt: off
+        js.TypedArray(u8), js.TypedArray(u16), js.TypedArray(u32), js.TypedArray(u64),
+        js.TypedArray(i8), js.TypedArray(i16), js.TypedArray(i32), js.TypedArray(i64),
+        js.TypedArray(f32), js.TypedArray(f64),
+        // zig fmt: on
+        => {
+            const ValueType = @typeInfo(std.meta.fieldInfo(T, .values).type).pointer.child;
+            const slice = (try self.jsValueToTypedArray(ValueType, js_value)) orelse return null;
+            return .{ .values = slice };
+        },
+        js.String => .{ .string = try self.valueToString(js_value, .{ .allocator = self.arena }) },
         // Caller wants an opaque js.Object. Probably a parameter
-        // that it needs to pass back into a callback
-        return js.Object{
-            .js_obj = js_obj,
+        // that it needs to pass back into a callback.
+        js.Object => js.Object{
+            .js_obj = js_value.castTo(v8.Object),
             .context = self,
-        };
-    }
-
+        },
+        else => {
+            const js_obj = js_value.castTo(v8.Object);
             if (!js_value.isObject()) {
                 return null;
             }
 
             const v8_context = self.v8_context;
             const isolate = self.isolate;
-
             var value: T = undefined;
             inline for (@typeInfo(T).@"struct".fields) |field| {
                 const name = field.name;
@@ -829,6 +827,8 @@ fn jsValueToStruct(self: *Context, comptime named_function: NamedFunction, compt
                 }
             }
             return value;
+        },
+    };
 }
 
 fn jsValueToTypedArray(_: *Context, comptime T: type, js_value: v8.Value) !?[]T {

src/browser/js/js.zig

@@ -48,8 +48,6 @@ const NamedFunction = Context.NamedFunction;
 // Env.JsObject. Want a TypedArray? Env.TypedArray.
 pub fn TypedArray(comptime T: type) type {
     return struct {
-        pub const _TYPED_ARRAY_ID_KLUDGE = true;
-
         values: []const T,
 
         pub fn dupe(self: TypedArray(T), allocator: Allocator) !TypedArray(T) {
@@ -327,9 +325,8 @@ pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bo
             return v8.initNull(isolate).toValue();
         },
         .@"struct" => {
-            const T = @TypeOf(value);
-
-            if (T == ArrayBuffer) {
+            switch (@TypeOf(value)) {
+                ArrayBuffer => {
                     const values = value.values;
                     const len = values.len;
                     var array_buffer: v8.ArrayBuffer = undefined;
@@ -339,16 +336,20 @@ pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bo
                     array_buffer = v8.ArrayBuffer.initWithBackingStore(isolate, &backing_store.toSharedPtr());
 
                     return .{ .handle = array_buffer.handle };
-            }
-
-            if (@hasDecl(T, "_TYPED_ARRAY_ID_KLUDGE")) {
+                },
+                // zig fmt: off
+                TypedArray(u8), TypedArray(u16), TypedArray(u32), TypedArray(u64),
+                TypedArray(i8), TypedArray(i16), TypedArray(i32), TypedArray(i64),
+                TypedArray(f32), TypedArray(f64),
+                // zig fmt: on
+                => {
                     const values = value.values;
                     const value_type = @typeInfo(@TypeOf(values)).pointer.child;
                     const len = values.len;
                     const bits = switch (@typeInfo(value_type)) {
                         .int => |n| n.bits,
                         .float => |f| f.bits,
-                    else => @compileError("Invalid TypeArray type: " ++ @typeName(value_type)),
+                        else => @compileError("Invalid TypedArray type: " ++ @typeName(value_type)),
                     };
 
                     var array_buffer: v8.ArrayBuffer = undefined;
@@ -388,7 +389,9 @@ pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bo
                     }
                     // We normally don't fail in this function unless fail == true
                     // but this can never be valid.
-                @compileError("Invalid TypeArray type: " ++ @typeName(value_type));
+                    @compileError("Invalid TypedArray type: " ++ @typeName(value_type));
+                },
+                else => {},
             }
         },
         .@"union" => return simpleZigValueToJs(isolate, std.meta.activeTag(value), fail),