lib: implement webidl dictionary converter and use it in structuredClone

This commit provides a factory to generate `dictionaryConverter`
compliant with the spec. The implemented factory function is used for
the `structuredClone` algorithm with updated test cases.
PR-URL: #55489
Reviewed-By: Matthew Aitken <maitken033380023@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

Author: jazelly

lib/internal/webidl.js

@@ -2,6 +2,7 @@
 
 const{
  ArrayPrototypePush,
+ ArrayPrototypeToSorted,
  MathAbs,
  MathMax,
  MathMin,
@@ -272,6 +273,67 @@ function type(V) {
 }
 }
 
+// https://webidl.spec.whatwg.org/#js-dictionary
+functioncreateDictionaryConverter(members){
+// The spec requires us to operate the members of a dictionary in
+// lexicographical order. We are doing this in the outer scope to
+// reduce the overhead that could happen in the returned function.
+constsortedMembers=ArrayPrototypeToSorted(members,(a,b)=>{
+if(a.key===b.key){
+return0;
+}
+returna.key<b.key ? -1 : 1;
+});
+
+returnfunction(
+V,
+opts=kEmptyObject,
+){
+if(V!=null&&type(V)!==OBJECT){
+throwmakeException(
+'cannot be converted to a dictionary',
+opts,
+);
+}
+
+constidlDict={__proto__: null};
+for(leti=0;i<sortedMembers.length;i++){
+constmember=sortedMembers[i];
+constkey=member.key;
+letjsMemberValue;
+if(V==null){
+jsMemberValue=undefined;
+}else{
+jsMemberValue=V[key];
+}
+
+if(jsMemberValue!==undefined){
+constmemberContext=opts.context ? `${key} in ${opts.context}` : `${key}`;
+constconverter=member.converter;
+constidlMemberValue=converter(
+jsMemberValue,
+{
+__proto__: null,
+prefix: opts.prefix,
+context: memberContext,
+},
+);
+idlDict[key]=idlMemberValue;
+}elseif(typeofmember.defaultValue==='function'){
+constidlMemberValue=member.defaultValue();
+idlDict[key]=idlMemberValue;
+}elseif(member.required){
+throwmakeException(
+`cannot be converted because of the missing '${key}'`,
+opts,
+);
+}
+}
+
+returnidlDict;
+};
+}
+
 // https://webidl.spec.whatwg.org/#es-sequence
 functioncreateSequenceConverter(converter){
 returnfunction(V,opts=kEmptyObject){
@@ -327,6 +389,7 @@ module.exports = {
  createEnumConverter,
  createInterfaceConverter,
  createSequenceConverter,
+ createDictionaryConverter,
  evenRound,
  makeException,
 };

lib/internal/worker/js_transferable.js

@@ -5,7 +5,6 @@ const {
 }=primordials;
 const{
 codes: {
-ERR_INVALID_ARG_TYPE,
 ERR_MISSING_ARGS,
 },
 }=require('internal/errors');
@@ -98,29 +97,31 @@ function markTransferMode(obj, cloneable = false, transferable = false) {
 obj[transfer_mode_private_symbol]=mode;
 }
 
+
+webidl.converters.StructuredSerializeOptions=webidl
+.createDictionaryConverter(
+[
+{
+key: 'transfer',
+converter: webidl.converters['sequence<object>'],
+defaultValue: ()=>[],
+},
+],
+);
+
 functionstructuredClone(value,options){
 if(arguments.length===0){
 thrownewERR_MISSING_ARGS('The value argument must be specified');
 }
 
-// TODO(jazelly): implement generic webidl dictionary converter
-constprefix='Options';
-constoptionsType=webidl.type(options);
-if(optionsType!=='Undefined'&&optionsType!=='Null'&&optionsType!=='Object'){
-thrownewERR_INVALID_ARG_TYPE(
-prefix,
-['object','null','undefined'],
-options,
-);
-}
-constkey='transfer';
-constidlOptions={__proto__: null,[key]: []};
-if(options!=null&&keyinoptions&&options[key]!==undefined){
-idlOptions[key]=webidl.converters['sequence<object>'](options[key],{
+constidlOptions=webidl.converters.StructuredSerializeOptions(
+options,
+{
 __proto__: null,
-context: 'Transfer',
-});
-}
+prefix: "Failed to execute 'structuredClone'",
+context: 'Options',
+},
+);
 
 constserializedData=nativeStructuredClone(value,idlOptions);
 returnserializedData;

test/parallel/test-structuredClone-global.js

@@ -3,12 +3,23 @@
 require('../common');
 constassert=require('assert');
 
+constprefix="Failed to execute 'structuredClone'";
+constkey='transfer';
+constcontext='Options';
+constmemberConverterError=`${prefix}: ${key} in ${context} can not be converted to sequence.`;
+constdictionaryConverterError=`${prefix}: ${context} cannot be converted to a dictionary`;
+
 assert.throws(()=>structuredClone(),{code: 'ERR_MISSING_ARGS'});
-assert.throws(()=>structuredClone(undefined,''),{code: 'ERR_INVALID_ARG_TYPE'});
-assert.throws(()=>structuredClone(undefined,1),{code: 'ERR_INVALID_ARG_TYPE'});
-assert.throws(()=>structuredClone(undefined,{transfer: 1}),{code: 'ERR_INVALID_ARG_TYPE'});
-assert.throws(()=>structuredClone(undefined,{transfer: ''}),{code: 'ERR_INVALID_ARG_TYPE'});
-assert.throws(()=>structuredClone(undefined,{transfer: null}),{code: 'ERR_INVALID_ARG_TYPE'});
+assert.throws(()=>structuredClone(undefined,''),
+{code: 'ERR_INVALID_ARG_TYPE',message: dictionaryConverterError});
+assert.throws(()=>structuredClone(undefined,1),
+{code: 'ERR_INVALID_ARG_TYPE',message: dictionaryConverterError});
+assert.throws(()=>structuredClone(undefined,{transfer: 1}),
+{code: 'ERR_INVALID_ARG_TYPE',message: memberConverterError});
+assert.throws(()=>structuredClone(undefined,{transfer: ''}),
+{code: 'ERR_INVALID_ARG_TYPE',message: memberConverterError});
+assert.throws(()=>structuredClone(undefined,{transfer: null}),
+{code: 'ERR_INVALID_ARG_TYPE',message: memberConverterError});
 
 // Options can be null or undefined.
 assert.strictEqual(structuredClone(undefined),undefined);