lib: implement webidl dictionary converter

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.

Author: jazelly

lib/internal/webidl.js

@@ -2,6 +2,7 @@
 
 const {
   ArrayPrototypePush,
+  ArrayPrototypeSort,
   MathAbs,
   MathMax,
   MathMin,
@@ -12,6 +13,7 @@ const {
   NumberMAX_SAFE_INTEGER,
   NumberMIN_SAFE_INTEGER,
   ObjectAssign,
+  ObjectPrototypeHasOwnProperty,
   ObjectPrototypeIsPrototypeOf,
   SafeSet,
   String,
@@ -263,6 +265,74 @@ function type(V) {
   }
 }
 
+// https://webidl.spec.whatwg.org/#js-dictionary
+function createDictionaryConverter(members) {
+  // The spec requires us to operate members of each dictionary in
+  // lexicographical order. We are doing all of these in the outer scope to
+  // reduce the overhead that could happen in the returned function.
+  const sortedMembers = [];
+  for (let i = 0; i < members.length; i++) {
+    const member = members[i];
+    ArrayPrototypePush(sortedMembers, member);
+  }
+
+  ArrayPrototypeSort(sortedMembers, (a, b) => {
+    if (a.key === b.key) {
+      return 0;
+    }
+    return a.key < b.key ? -1 : 1;
+  });
+
+  return function(
+    V,
+    opts = kEmptyObject,
+  ) {
+    const typeV = type(V);
+    if (typeV !== 'Undefined' && typeV !== 'Null' && typeV !== 'Object') {
+      throw makeException(
+        'can not be converted to a dictionary',
+        opts,
+      );
+    }
+
+    const idlDict = { __proto__: null };
+    for (let i = 0; i < sortedMembers.length; i++) {
+      const member = sortedMembers[i];
+      const key = member.key;
+      let jsMemberValue;
+      if (typeV === 'Undefined' || typeV === 'Null') {
+        jsMemberValue = undefined;
+      } else {
+        jsMemberValue = V[key];
+      }
+
+      if (jsMemberValue !== undefined) {
+        const memberContext = opts.context ? `${key} in ${opts.context}` : `${key}`;
+        const converter = member.converter;
+        const idlMemberValue = converter(
+          jsMemberValue,
+          {
+            __proto__: null,
+            prefix: opts.prefix,
+            context: memberContext,
+          },
+        );
+        idlDict[key] = idlMemberValue;
+      } else if (ObjectPrototypeHasOwnProperty(member, 'defaultValue')) {
+        const idlMemberValue = member.defaultValue;
+        idlDict[key] = idlMemberValue;
+      } else if (member.required) {
+        throw makeException(
+          `can not be converted because of the missing '${key}'`,
+          opts,
+        );
+      }
+    }
+
+    return idlDict;
+  };
+}
+
 // https://webidl.spec.whatwg.org/#es-sequence
 function createSequenceConverter(converter) {
   return function(V, opts = kEmptyObject) {
@@ -318,6 +388,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,33 @@ function markTransferMode(obj, cloneable = false, transferable = false) {
   obj[transfer_mode_private_symbol] = mode;
 }
 
+
+webidl.converters.StructuredCloneOptions = webidl
+  .createDictionaryConverter(
+    [
+      {
+        key: 'transfer',
+        converter: webidl.converters['sequence<object>'],
+        get defaultValue() {
+          return [];
+        },
+      },
+    ],
+  );
+
 function structuredClone(value, options) {
   if (arguments.length === 0) {
     throw new ERR_MISSING_ARGS('The value argument must be specified');
   }
 
-  // TODO(jazelly): implement generic webidl dictionary converter
-  const prefix = 'Options';
-  const optionsType = webidl.type(options);
-  if (optionsType !== 'Undefined' && optionsType !== 'Null' && optionsType !== 'Object') {
-    throw new ERR_INVALID_ARG_TYPE(
-      prefix,
-      ['object', 'null', 'undefined'],
-      options,
-    );
-  }
-  const key = 'transfer';
-  const idlOptions = { __proto__: null, [key]: [] };
-  if (options != null && key in options && options[key] !== undefined) {
-    idlOptions[key] = webidl.converters['sequence<object>'](options[key], {
+  const idlOptions = webidl.converters.StructuredCloneOptions(
+    options,
+    {
       __proto__: null,
-      context: 'Transfer',
-    });
-  }
+      prefix: "Failed to execute 'structuredClone'",
+      context: 'Options',
+    },
+  );
 
   const serializedData = nativeStructuredClone(value, idlOptions);
   return serializedData;

test/parallel/test-structuredClone-global.js

@@ -3,12 +3,23 @@
 require('../common');
 const assert = require('assert');
 
+const prefix = "Failed to execute 'structuredClone'";
+const key = 'transfer';
+const context = 'Options';
+const memberConverterError = `${prefix}: ${key} in ${context} can not be converted to sequence.`;
+const dictionaryConverterError = `${prefix}: ${context} can not 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);