Merge pull request #1269 from lightpanda-io/nikneym/zigdom-fix-kludge-hack

backport: Remove `_TYPED_ARRAY_ID_KLUDGE` hack

src/browser/js/Context.zig

@@ -821,47 +821,42 @@ pub fn jsValueToZig(self: *Context, comptime T: type, js_value: v8.Value) !T {
 // 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 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;
+        },
+        // 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 arr = (try self.jsValueToTypedArray(ValueType, js_value)) orelse return null;
             return .{ .values = arr };
-    }
-
-    if (T == js.String) {
-        return .{ .string = try self.valueToString(js_value, .{ .allocator = self.arena }) };
-    }
-
-    if (comptime T == js.Value) {
+        },
+        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.Value{
-            .context = self,
+        // that it needs to pass back into a callback.
+        js.Value => js.Value{
             .js_val = js_value,
-        };
-    }
-
-    const js_obj = js_value.castTo(v8.Object);
-
-    if (comptime T == js.Object) {
-        // 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,
             .context = self,
-        };
-    }
-
+        },
+        // Caller wants an opaque js.Object. Probably a parameter
+        // that it needs to pass back into a callback.
+        js.Object => js.Object{
+            .js_obj = js_value.castTo(v8.Object),
+            .context = self,
+        },
+        else => {
             if (!js_value.isObject()) {
                 return null;
             }
 
+            const js_obj = js_value.castTo(v8.Object);
             const v8_context = self.v8_context;
             const isolate = self.isolate;
 
@@ -878,7 +873,10 @@ fn jsValueToStruct(self: *Context, comptime T: type, js_value: v8.Value) !?T {
                     @field(value, name) = dflt;
                 }
             }
+
             return value;
+        },
+    };
 }
 
 fn jsValueToTypedArray(_: *Context, comptime T: type, js_value: v8.Value) !?[]T {

src/browser/js/js.zig

@@ -53,8 +53,6 @@ pub fn Bridge(comptime T: type) type {
 // 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) {
@@ -63,6 +61,14 @@ pub fn TypedArray(comptime T: type) type {
     };
 }
 
+pub const ArrayBuffer = struct {
+    values: []const u8,
+
+    pub fn dupe(self: ArrayBuffer, allocator: Allocator) !ArrayBuffer {
+        return .{ .values = try allocator.dupe(u8, self.values) };
+    }
+};
+
 pub const PromiseResolver = struct {
     context: *Context,
     resolver: v8.PromiseResolver,
@@ -317,8 +323,24 @@ pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bo
             return v8.initNull(isolate).toValue();
         },
         .@"struct" => {
-            const T = @TypeOf(value);
-            if (@hasDecl(T, "_TYPED_ARRAY_ID_KLUDGE")) {
+            switch (@TypeOf(value)) {
+                ArrayBuffer => {
+                    const values = value.values;
+                    const len = values.len;
+                    var array_buffer: v8.ArrayBuffer = undefined;
+                    const backing_store = v8.BackingStore.init(isolate, len);
+                    const data: [*]u8 = @ptrCast(@alignCast(backing_store.getData()));
+                    @memcpy(data[0..len], @as([]const u8, @ptrCast(values))[0..len]);
+                    array_buffer = v8.ArrayBuffer.initWithBackingStore(isolate, &backing_store.toSharedPtr());
+
+                    return .{ .handle = array_buffer.handle };
+                },
+                // 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;
@@ -366,6 +388,8 @@ 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));
+                },
+                else => {},
             }
         },
         .@"union" => return simpleZigValueToJs(isolate, std.meta.activeTag(value), fail, null_as_undefined),