Element.matches, Element.hasAttributes and DOMStringMap (Element.dataset)

Author: karlseguin

src/browser/Page.zig

@@ -63,6 +63,9 @@ _attribute_lookup: std.AutoHashMapUnmanaged(usize, *Element.Attribute),
 // the return of elements.attributes.
 _attribute_named_node_map_lookup: std.AutoHashMapUnmanaged(usize, *Element.Attribute.NamedNodeMap),
 
+// element.dataset -> DOMStringMap
+_element_datasets: std.AutoHashMapUnmanaged(*Element, *Element.DOMStringMap),
+
 _script_manager: ScriptManager,
 
 _polyfill_loader: polyfill.Loader = .{},
@@ -152,6 +155,7 @@ fn reset(self: *Page, comptime initializing: bool) !void {
     self._load_state = .parsing;
     self._attribute_lookup = .empty;
     self._attribute_named_node_map_lookup = .empty;
+    self._element_datasets = .empty;
     self._event_manager = EventManager.init(self);
 
     self._script_manager = ScriptManager.init(self);

src/browser/ScriptManager.zig

@@ -707,7 +707,6 @@ const Script = struct {
             .cacheable = cacheable,
         });
 
-
         // Handle importmap special case here: the content is a JSON containing
         // imports.
         if (self.kind == .importmap) {

src/browser/js/Caller.zig

@@ -157,7 +157,7 @@ pub fn _getIndex(self: *Caller, comptime T: type, func: anytype, idx: u32, info:
     @field(args, "0") = try Context.typeTaggedAnyOpaque(*T, info.getThis());
     @field(args, "1") = idx;
     const ret = @call(.auto, func, args);
-    return self.handleIndexedReturn(T, F, ret, info, opts);
+    return self.handleIndexedReturn(T, F, true, ret, info, opts);
 }
 
 pub fn getNamedIndex(self: *Caller, comptime T: type, func: anytype, name: v8.Name, info: v8.PropertyCallbackInfo, comptime opts: CallOpts) u8 {
@@ -173,10 +173,49 @@ pub fn _getNamedIndex(self: *Caller, comptime T: type, func: anytype, name: v8.N
     @field(args, "0") = try Context.typeTaggedAnyOpaque(*T, info.getThis());
     @field(args, "1") = try self.nameToString(name);
     const ret = @call(.auto, func, args);
-    return self.handleIndexedReturn(T, F, ret, info, opts);
+    return self.handleIndexedReturn(T, F, true, ret, info, opts);
 }
 
-fn handleIndexedReturn(self: *Caller, comptime T: type, comptime F: type, ret: anytype, info: v8.PropertyCallbackInfo, comptime opts: CallOpts) !u8 {
+pub fn setNamedIndex(self: *Caller, comptime T: type, func: anytype, name: v8.Name, js_value: v8.Value, info: v8.PropertyCallbackInfo, comptime opts: CallOpts) u8 {
+    return self._setNamedIndex(T, func, name, js_value, info, opts) catch |err| {
+        self.handleError(T, @TypeOf(func), err, info, opts);
+        return v8.Intercepted.No;
+    };
+}
+
+pub fn _setNamedIndex(self: *Caller, comptime T: type, func: anytype, name: v8.Name, js_value: v8.Value, info: v8.PropertyCallbackInfo, comptime opts: CallOpts) !u8 {
+    const F = @TypeOf(func);
+    var args: ParameterTypes(F) = undefined;
+    @field(args, "0") = try Context.typeTaggedAnyOpaque(*T, info.getThis());
+    @field(args, "1") = try self.nameToString(name);
+    @field(args, "2") = try self.context.jsValueToZig(@TypeOf(@field(args, "2")), js_value);
+    if (@typeInfo(F).@"fn".params.len == 4) {
+        @field(args, "3") = self.context.page;
+    }
+    const ret = @call(.auto, func, args);
+    return self.handleIndexedReturn(T, F, false, ret, info, opts);
+}
+
+pub fn deleteNamedIndex(self: *Caller, comptime T: type, func: anytype, name: v8.Name, info: v8.PropertyCallbackInfo, comptime opts: CallOpts) u8 {
+    return self._deleteNamedIndex(T, func, name, info, opts) catch |err| {
+        self.handleError(T, @TypeOf(func), err, info, opts);
+        return v8.Intercepted.No;
+    };
+}
+
+pub fn _deleteNamedIndex(self: *Caller, comptime T: type, func: anytype, name: v8.Name, info: v8.PropertyCallbackInfo, comptime opts: CallOpts) !u8 {
+    const F = @TypeOf(func);
+    var args: ParameterTypes(F) = undefined;
+    @field(args, "0") = try Context.typeTaggedAnyOpaque(*T, info.getThis());
+    @field(args, "1") = try self.nameToString(name);
+    if (@typeInfo(F).@"fn".params.len == 3) {
+        @field(args, "2") = self.context.page;
+    }
+    const ret = @call(.auto, func, args);
+    return self.handleIndexedReturn(T, F, false, ret, info, opts);
+}
+
+fn handleIndexedReturn(self: *Caller, comptime T: type, comptime F: type, comptime getter: bool, ret: anytype, info: v8.PropertyCallbackInfo, comptime opts: CallOpts) !u8 {
     // need to unwrap this error immediately for when opts.null_as_undefined == true
     // and we need to compare it to null;
     const non_error_ret = switch (@typeInfo(@TypeOf(ret))) {
@@ -197,7 +236,9 @@ fn handleIndexedReturn(self: *Caller, comptime T: type, comptime F: type, ret: a
         else => ret,
     };
 
-    info.getReturnValue().set(try self.context.zigValueToJs(non_error_ret, opts));
+    if (comptime getter) {
+        info.getReturnValue().set(try self.context.zigValueToJs(non_error_ret, opts));
+    }
     return v8.Intercepted.Yes;
 }
 

src/browser/js/Env.zig

@@ -253,13 +253,12 @@ pub fn attachClass(comptime JsApi: type, isolate: v8.Isolate, template: v8.Funct
                 };
                 template_proto.setIndexedProperty(configuration, null);
             },
-            bridge.NamedIndexed => {
-                const configuration = v8.NamedPropertyHandlerConfiguration{
-                    .getter = value.getter,
-                    .flags = v8.PropertyHandlerFlags.OnlyInterceptStrings | v8.PropertyHandlerFlags.NonMasking,
-                };
-                template_proto.setNamedProperty(configuration, null);
-            },
+            bridge.NamedIndexed => template.getInstanceTemplate().setNamedProperty(.{
+                .getter = value.getter,
+                .setter = value.setter,
+                .deleter = value.deleter,
+                .flags = v8.PropertyHandlerFlags.OnlyInterceptStrings | v8.PropertyHandlerFlags.NonMasking,
+            }, null),
             bridge.Iterator => {
                 // Same as a function, but with a specific name
                 const function_template = v8.FunctionTemplate.initCallback(isolate, value.func);
@@ -326,7 +325,6 @@ fn generateConstructor(comptime JsApi: type, isolate: v8.Isolate) v8.FunctionTem
 
 //     if (has_js_call_as_function) {
 
-
 //     if (@hasDecl(Struct, "htmldda") and Struct.htmldda) {
 //         if (!has_js_call_as_function) {
 //             @compileError(@typeName(Struct) ++ ": htmldda required jsCallAsFunction to be defined. This is a hard-coded requirement in V8, because mark_as_undetectable only exists for HTMLAllCollection which is also callable.");

src/browser/js/bridge.zig

@@ -45,8 +45,8 @@ pub fn Builder(comptime T: type) type {
             return Indexed.init(T, getter_func, opts);
         }
 
-        pub fn namedIndexed(comptime getter_func: anytype, comptime opts: NamedIndexed.Opts) NamedIndexed {
-            return NamedIndexed.init(T, getter_func, opts);
+        pub fn namedIndexed(comptime getter_func: anytype, setter_func: anytype, deleter_func: anytype, comptime opts: NamedIndexed.Opts) NamedIndexed {
+            return NamedIndexed.init(T, getter_func, setter_func, deleter_func, opts);
         }
 
         pub fn iterator(comptime func: anytype, comptime opts: Iterator.Opts) Iterator {
@@ -221,14 +221,16 @@ pub const Indexed = struct {
 
 pub const NamedIndexed = struct {
     getter: *const fn (c_name: ?*const v8.C_Name, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8,
+    setter: ?*const fn (c_name: ?*const v8.C_Name, c_value: ?*const v8.C_Value, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 = null,
+    deleter: ?*const fn (c_name: ?*const v8.C_Name, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 = null,
 
     const Opts = struct {
         as_typed_array: bool = false,
         null_as_undefined: bool = false,
     };
 
-    fn init(comptime T: type, comptime getter: anytype, comptime opts: Opts) NamedIndexed {
-        return .{ .getter = struct {
+    fn init(comptime T: type, comptime getter: anytype, setter: anytype, deleter: anytype, comptime opts: Opts) NamedIndexed {
+        const getter_fn = struct {
             fn wrap(c_name: ?*const v8.C_Name, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
                 const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
                 var caller = Caller.init(info);
@@ -238,7 +240,39 @@ pub const NamedIndexed = struct {
                     .null_as_undefined = opts.null_as_undefined,
                 });
             }
-        }.wrap };
+        }.wrap;
+
+        const setter_fn = if (@typeInfo(@TypeOf(setter)) == .null) null else struct {
+            fn wrap(c_name: ?*const v8.C_Name, c_value: ?*const v8.C_Value, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
+                const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
+                var caller = Caller.init(info);
+                defer caller.deinit();
+
+                return caller.setNamedIndex(T, setter, .{ .handle = c_name.? }, .{ .handle = c_value.? }, info, .{
+                    .as_typed_array = opts.as_typed_array,
+                    .null_as_undefined = opts.null_as_undefined,
+                });
+            }
+        }.wrap;
+
+        const deleter_fn = if (@typeInfo(@TypeOf(deleter)) == .null) null else struct {
+            fn wrap(c_name: ?*const v8.C_Name, raw_info: ?*const v8.C_PropertyCallbackInfo) callconv(.c) u8 {
+                const info = v8.PropertyCallbackInfo.initFromV8(raw_info);
+                var caller = Caller.init(info);
+                defer caller.deinit();
+
+                return caller.deleteNamedIndex(T, deleter, .{ .handle = c_name.? }, info, .{
+                    .as_typed_array = opts.as_typed_array,
+                    .null_as_undefined = opts.null_as_undefined,
+                });
+            }
+        }.wrap;
+
+        return .{
+            .getter = getter_fn,
+            .setter = setter_fn,
+            .deleter = deleter_fn,
+        };
     }
 };
 
@@ -269,7 +303,6 @@ pub const Iterator = struct {
     }
 };
 
-
 pub const Callable = struct {
     func: *const fn (?*const v8.C_FunctionCallbackInfo) callconv(.c) void,
 
@@ -278,16 +311,16 @@ pub const Callable = struct {
     };
 
     fn init(comptime T: type, comptime func: anytype, comptime opts: Opts) Callable {
-        return .{.func = struct {
+        return .{ .func = struct {
             fn wrap(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
                 const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
                 var caller = Caller.init(info);
                 defer caller.deinit();
                 caller.method(T, func, info, .{
                     .null_as_undefined = opts.null_as_undefined,
                 });
-            }}.wrap
-        };
+            }
+        }.wrap };
     }
 };
 
@@ -457,6 +490,7 @@ pub const JsApis = flattenTypes(&.{
     @import("../webapi/DOMNodeIterator.zig"),
     @import("../webapi/NodeFilter.zig"),
     @import("../webapi/Element.zig"),
+    @import("../webapi/element/DOMStringMap.zig"),
     @import("../webapi/element/Attribute.zig"),
     @import("../webapi/element/Html.zig"),
     @import("../webapi/element/html/IFrame.zig"),

src/browser/tests/element/attributes.html

@@ -83,3 +83,22 @@
 
   assertAttributes([{name: 'id', value: 'attr1'}, {name: 'class', value: 'sHow'}]);
 </script>
+
+<script id=hasAttribute>
+{
+  const el1 = $('#attr1');
+
+  testing.expectEqual(true, el1.hasAttribute('id'));
+  testing.expectEqual(true, el1.hasAttribute('ID'));
+  testing.expectEqual(true, el1.hasAttribute('class'));
+  testing.expectEqual(true, el1.hasAttribute('CLASS'));
+  testing.expectEqual(false, el1.hasAttribute('other'));
+  testing.expectEqual(false, el1.hasAttribute('nope'));
+
+  el1.setAttribute('data-test', 'value');
+  testing.expectEqual(true, el1.hasAttribute('data-test'));
+
+  el1.removeAttribute('data-test');
+  testing.expectEqual(false, el1.hasAttribute('data-test'));
+}
+</script>