lib: use webidl DOMString converter in EventTarget

PR-URL: #47514
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

Author: KhafraDev

lib/internal/event_target.js

@@ -42,6 +42,7 @@ const {
  kEnumerableProperty,
 }=require('internal/util');
 const{ inspect }=require('util');
+constwebidl=require('internal/webidl');
 
 constkIsEventTarget=SymbolFor('nodejs.event_target');
 constkIsNodeEventTarget=Symbol('kIsNodeEventTarget');
@@ -577,7 +578,7 @@ class EventTarget {
 process.emitWarning(w);
 return;
 }
-type=String(type);
+type=webidl.converters.DOMString(type);
 
 if(signal){
 if(signal.aborted){
@@ -643,7 +644,7 @@ class EventTarget {
 if(!validateEventListener(listener))
 return;
 
-type=String(type);
+type=webidl.converters.DOMString(type);
 constcapture=options?.capture===true;
 
 constroot=this[kEvents].get(type);

lib/internal/webidl.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const{
+ MathAbs,
+ MathMax,
+ MathMin,
+ MathPow,
+ MathSign,
+ MathTrunc,
+ NumberIsNaN,
+ NumberMAX_SAFE_INTEGER,
+ NumberMIN_SAFE_INTEGER,
+ String,
+}=primordials;
+
+const{
+codes: {
+ERR_INVALID_ARG_VALUE,
+},
+}=require('internal/errors');
+const{ kEmptyObject }=require('internal/util');
+
+constconverters={__proto__: null};
+
+// https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+constintegerPart=MathTrunc;
+
+/* eslint-disable node-core/non-ascii-character */
+// Round x to the nearest integer, choosing the even integer if it lies halfway
+// between two, and choosing +0 rather than -0.
+// This is different from Math.round, which rounds to the next integer in the
+// direction of +∞ when the fraction portion is exactly 0.5.
+/* eslint-enable node-core/non-ascii-character */
+functionevenRound(x){
+// Convert -0 to +0.
+consti=integerPart(x)+0;
+constreminder=MathAbs(x%1);
+constsign=MathSign(i);
+if(reminder===0.5){
+returni%2===0 ? i : i+sign;
+}
+constr=reminder<0.5 ? i : i+sign;
+// Convert -0 to +0.
+if(r===0){
+return0;
+}
+returnr;
+}
+
+functionpow2(exponent){
+// << operates on 32 bit signed integers.
+if(exponent<31){
+return1<<exponent;
+}
+if(exponent===31){
+return0x8000_0000;
+}
+if(exponent===32){
+return0x1_0000_0000;
+}
+returnMathPow(2,exponent);
+}
+
+// https://tc39.es/ecma262/#eqn-modulo
+// The notation “x modulo y” computes a value k of the same sign as y.
+functionmodulo(x,y){
+constr=x%y;
+// Convert -0 to +0.
+if(r===0){
+return0;
+}
+returnr;
+}
+
+// https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+functionconvertToInt(name,value,bitLength,options=kEmptyObject){
+const{ signed =false, enforceRange =false, clamp =false}=options;
+
+letupperBound;
+letlowerBound;
+// 1. If bitLength is 64, then:
+if(bitLength===64){
+// 1.1. Let upperBound be 2^53 − 1.
+upperBound=NumberMAX_SAFE_INTEGER;
+// 1.2. If signedness is "unsigned", then let lowerBound be 0.
+// 1.3. Otherwise let lowerBound be −2^53 + 1.
+lowerBound=!signed ? 0 : NumberMIN_SAFE_INTEGER;
+}elseif(!signed){
+// 2. Otherwise, if signedness is "unsigned", then:
+// 2.1. Let lowerBound be 0.
+// 2.2. Let upperBound be 2^bitLength − 1.
+lowerBound=0;
+upperBound=pow2(bitLength)-1;
+}else{
+// 3. Otherwise:
+// 3.1. Let lowerBound be -2^(bitLength − 1).
+// 3.2. Let upperBound be 2^(bitLength − 1) − 1.
+lowerBound=-pow2(bitLength-1);
+upperBound=pow2(bitLength-1)-1;
+}
+
+// 4. Let x be ? ToNumber(V).
+letx=+value;
+// 5. If x is −0, then set x to +0.
+if(x===0){
+x=0;
+}
+
+// 6. If the conversion is to an IDL type associated with the [EnforceRange]
+// extended attribute, then:
+if(enforceRange){
+// 6.1. If x is NaN, +∞, or −∞, then throw a TypeError.
+if(NumberIsNaN(x)||x===Infinity||x===-Infinity){
+thrownewERR_INVALID_ARG_VALUE(name,x);
+}
+// 6.2. Set x to IntegerPart(x).
+x=integerPart(x);
+
+// 6.3. If x < lowerBound or x > upperBound, then throw a TypeError.
+if(x<lowerBound||x>upperBound){
+thrownewERR_INVALID_ARG_VALUE(name,x);
+}
+
+// 6.4. Return x.
+returnx;
+}
+
+// 7. If x is not NaN and the conversion is to an IDL type associated with
+// the [Clamp] extended attribute, then:
+if(clamp&&!NumberIsNaN(x)){
+// 7.1. Set x to min(max(x, lowerBound), upperBound).
+x=MathMin(MathMax(x,lowerBound),upperBound);
+
+// 7.2. Round x to the nearest integer, choosing the even integer if it
+// lies halfway between two, and choosing +0 rather than −0.
+x=evenRound(x);
+
+// 7.3. Return x.
+returnx;
+}
+
+// 8. If x is NaN, +0, +∞, or −∞, then return +0.
+if(NumberIsNaN(x)||x===0||x===Infinity||x===-Infinity){
+return0;
+}
+
+// 9. Set x to IntegerPart(x).
+x=integerPart(x);
+
+// 10. Set x to x modulo 2^bitLength.
+x=modulo(x,pow2(bitLength));
+
+// 11. If signedness is "signed" and x ≥ 2^(bitLength − 1), then return x −
+// 2^bitLength.
+if(signed&&x>=pow2(bitLength-1)){
+returnx-pow2(bitLength);
+}
+
+// 12. Otherwise, return x.
+returnx;
+}
+
+/**
+ * @see https://webidl.spec.whatwg.org/#es-DOMString
+ * @param {any} V
+ * @returns {string}
+ */
+converters.DOMString=functionDOMString(V){
+if(typeofV==='symbol'){
+thrownewERR_INVALID_ARG_VALUE('value',V);
+}
+
+returnString(V);
+};
+
+module.exports={
+ convertToInt,
+ evenRound,
+ converters,
+};

test/parallel/test-bootstrap-modules.js

@@ -151,6 +151,7 @@ const expectedModules = new Set([
 'NativeModule internal/vm',
 'NativeModule internal/vm/module',
 'NativeModule internal/wasm_web_api',
+'NativeModule internal/webidl',
 'NativeModule internal/webstreams/adapters',
 'NativeModule internal/webstreams/compression',
 'NativeModule internal/webstreams/encoding',

test/parallel/test-eventtarget.js

@@ -705,3 +705,15 @@ let asyncTest = Promise.resolve();
 name: 'TypeError',
 });
 }
+
+{
+constet=newEventTarget();
+
+throws(()=>{
+et.addEventListener(Symbol('symbol'),()=>{});
+},TypeError);
+
+throws(()=>{
+et.removeEventListener(Symbol('symbol'),()=>{});
+},TypeError);
+}