url: more precise URLSearchParams constructor

PR-URL: #13026 Ref: web-platform-tests/wpt#5813 Reviewed-By: Daijiro Wachi <[email protected]> Reviewed-By: Joyee Cheung <[email protected]> Reviewed-By: James M Snell <[email protected]>

Author: TimothyGu

lib/internal/url.js

@@ -814,7 +814,8 @@ class URLSearchParams{
 constructor(init=undefined){
 if(init===null||init===undefined){
 this[searchParams]=[];
-}elseif(typeofinit==='object'){
+}elseif((typeofinit==='object'&&init!==null)||
+typeofinit==='function'){
 constmethod=init[Symbol.iterator];
 if(method===this[Symbol.iterator]){
 // While the spec does not have this branch, we can use it as a
@@ -830,12 +831,16 @@ class URLSearchParams{
 // Note: per spec we have to first exhaust the lists then process them
 constpairs=[];
 for(constpairofinit){
-if(typeofpair!=='object'||
+if((typeofpair!=='object'&&typeofpair!=='function')||
+pair===null||
 typeofpair[Symbol.iterator]!=='function'){
 thrownewerrors.TypeError('ERR_INVALID_TUPLE','Each query pair',
 '[name, value]');
 }
-pairs.push(Array.from(pair));
+constconvertedPair=[];
+for(constelementofpair)
+convertedPair.push(toUSVString(element));
+pairs.push(convertedPair);
 }
 
 this[searchParams]=[];
@@ -844,17 +849,21 @@ class URLSearchParams{
 thrownewerrors.TypeError('ERR_INVALID_TUPLE','Each query pair',
 '[name, value]');
 }
-constkey=toUSVString(pair[0]);
-constvalue=toUSVString(pair[1]);
-this[searchParams].push(key,value);
+this[searchParams].push(pair[0],pair[1]);
 }
 }else{
 // record<USVString, USVString>
+// Need to use reflection APIs for full spec compliance.
 this[searchParams]=[];
-for(varkeyofObject.keys(init)){
-key=toUSVString(key);
-constvalue=toUSVString(init[key]);
-this[searchParams].push(key,value);
+constkeys=Reflect.ownKeys(init);
+for(vari=0;i<keys.length;i++){
+constkey=keys[i];
+constdesc=Reflect.getOwnPropertyDescriptor(init,key);
+if(desc!==undefined&&desc.enumerable){
+consttypedKey=toUSVString(key);
+consttypedValue=toUSVString(init[key]);
+this[searchParams].push(typedKey,typedValue);
+}
 }
 }
 }else{

test/parallel/test-whatwg-url-searchparams-constructor.js

@@ -11,7 +11,7 @@ const{
 /* eslint-disable */
 varparams;// Strict mode fix for WPT.
 /* WPT Refs:
- https://github.com/w3c/web-platform-tests/blob/e94c604916/url/urlsearchparams-constructor.html
+ https://github.com/w3c/web-platform-tests/blob/54c3502d7b/url/urlsearchparams-constructor.html
  License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
 */
 test(function(){
@@ -87,6 +87,17 @@ test(function(){
 assert_equals(params.get('a b'),'c');
 },'Parse +');
 
+test(function(){
+consttestValue='+15555555555';
+constparams=newURLSearchParams();
+params.set('query',testValue);
+varnewParams=newURLSearchParams(params.toString());
+
+assert_equals(params.toString(),'query=%2B15555555555');
+assert_equals(params.get('query'),testValue);
+assert_equals(newParams.get('query'),testValue);
+},'Parse encoded +');
+
 test(function(){
 varparams=newURLSearchParams('a=b c');
 assert_equals(params.get('a'),'b c');
@@ -156,7 +167,8 @@ test(function(){
 [
 {"input": {"+": "%C2"},"output": [["+","%C2"]],"name": "object with +"},
 {"input": {c: "x",a: "?"},"output": [["c","x"],["a","?"]],"name": "object with two keys"},
-{"input": [["c","x"],["a","?"]],"output": [["c","x"],["a","?"]],"name": "array with two keys"}
+{"input": [["c","x"],["a","?"]],"output": [["c","x"],["a","?"]],"name": "array with two keys"},
+{"input": {"a\0b": "42","c\uD83D": "23","d\u1234": "foo"},"output": [["a\0b","42"],["c\uFFFD","23"],["d\u1234","foo"]],"name": "object with NULL, non-ASCII, and surrogate keys"}
 ].forEach((val)=>{
 test(()=>{
 letparams=newURLSearchParams(val.input),
@@ -179,12 +191,12 @@ test(() =>{
 /* eslint-enable */
 
 // Tests below are not from WPT.
-{
-// assert.throws(() =>{
-// new URLSearchParams({
-// toString(){throw new TypeError('Illegal invocation')}
-// });
-// }, TypeError);
+functionmakeIterableFunc(array){
+returnObject.assign(()=>{},{
+[Symbol.iterator](){
+returnarray[Symbol.iterator]();
+}
+});
 }
 
 {
@@ -200,17 +212,25 @@ test(() =>{
 });
 
 letparams;
-// URLSearchParams constructor, undefined and null as argument
 params=newURLSearchParams(undefined);
 assert.strictEqual(params.toString(),'');
 params=newURLSearchParams(null);
 assert.strictEqual(params.toString(),'');
+params=newURLSearchParams(
+makeIterableFunc([['key','val'],['key2','val2']])
+);
+assert.strictEqual(params.toString(),'key=val&key2=val2');
+params=newURLSearchParams(
+makeIterableFunc([['key','val'],['key2','val2']].map(makeIterableFunc))
+);
+assert.strictEqual(params.toString(),'key=val&key2=val2');
 assert.throws(()=>newURLSearchParams([[1]]),tupleError);
 assert.throws(()=>newURLSearchParams([[1,2,3]]),tupleError);
 assert.throws(()=>newURLSearchParams({[Symbol.iterator]: 42}),
 iterableError);
 assert.throws(()=>newURLSearchParams([{}]),tupleError);
 assert.throws(()=>newURLSearchParams(['a']),tupleError);
+assert.throws(()=>newURLSearchParams([null]),tupleError);
 assert.throws(()=>newURLSearchParams([{[Symbol.iterator]: 42}]),
 tupleError);
 }
@@ -221,15 +241,14 @@ test(() =>{
 valueOf(){thrownewError('valueOf');}
 };
 constsym=Symbol();
-
-assert.throws(()=>newURLSearchParams({a: obj}),/^Error:toString$/);
-assert.throws(()=>newURLSearchParams([['a',obj]]),/^Error:toString$/);
-assert.throws(()=>newURLSearchParams(sym),
-/^TypeError:CannotconvertaSymbolvaluetoastring$/);
-assert.throws(()=>newURLSearchParams({a: sym}),
-/^TypeError:CannotconvertaSymbolvaluetoastring$/);
-assert.throws(()=>newURLSearchParams([[sym,'a']]),
-/^TypeError:CannotconvertaSymbolvaluetoastring$/);
-assert.throws(()=>newURLSearchParams([['a',sym]]),
-/^TypeError:CannotconvertaSymbolvaluetoastring$/);
+consttoStringError=/^Error:toString$/;
+constsymbolError=/^TypeError:CannotconvertaSymbolvaluetoastring$/;
+
+assert.throws(()=>newURLSearchParams({a: obj}),toStringError);
+assert.throws(()=>newURLSearchParams([['a',obj]]),toStringError);
+assert.throws(()=>newURLSearchParams(sym),symbolError);
+assert.throws(()=>newURLSearchParams({[sym]: 'a'}),symbolError);
+assert.throws(()=>newURLSearchParams({a: sym}),symbolError);
+assert.throws(()=>newURLSearchParams([[sym,'a']]),symbolError);
+assert.throws(()=>newURLSearchParams([['a',sym]]),symbolError);
 }