url: align default argument handling for URLPattern with webidl

Author: panva

src/node_url_pattern.cc

@@ -202,7 +202,11 @@ void URLPattern::New(const FunctionCallbackInfo<Value>& args) {
   // - new URLPattern(input, baseURL)
   // - new URLPattern(input, options)
   // - new URLPattern(input, baseURL, options)
-  if (args[0]->IsString()) {
+  // Per WebIDL, null/undefined for a union type including a dictionary
+  // uses the default value (empty init).
+  if (args[0]->IsNullOrUndefined()) {
+    init = ada::url_pattern_init{};
+  } else if (args[0]->IsString()) {
     BufferValue input_buffer(env->isolate(), args[0]);
     CHECK_NOT_NULL(*input_buffer);
     input = input_buffer.ToString();
@@ -218,7 +222,7 @@ void URLPattern::New(const FunctionCallbackInfo<Value>& args) {
   }
 
   // The next argument can be baseURL or options.
-  if (args.Length() > 1) {
+  if (args.Length() > 1 && !args[1]->IsNullOrUndefined()) {
     if (args[1]->IsString()) {
       BufferValue base_url_buffer(env->isolate(), args[1]);
       CHECK_NOT_NULL(*base_url_buffer);
@@ -239,7 +243,7 @@ void URLPattern::New(const FunctionCallbackInfo<Value>& args) {
     }
 
     // Only remaining argument can be options.
-    if (args.Length() > 2) {
+    if (args.Length() > 2 && !args[2]->IsNullOrUndefined()) {
       if (!args[2]->IsObject()) {
         THROW_ERR_INVALID_ARG_TYPE(env, "options must be an object");
         return;
@@ -564,7 +568,7 @@ void URLPattern::Exec(const FunctionCallbackInfo<Value>& args) {
   ada::url_pattern_input input;
   std::optional<std::string> baseURL{};
   std::string input_base;
-  if (args.Length() == 0) {
+  if (args.Length() == 0 || args[0]->IsNullOrUndefined()) {
     input = ada::url_pattern_init{};
   } else if (args[0]->IsString()) {
     Utf8Value input_value(env->isolate(), args[0].As<String>());
@@ -580,7 +584,7 @@ void URLPattern::Exec(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  if (args.Length() > 1) {
+  if (args.Length() > 1 && !args[1]->IsNullOrUndefined()) {
     if (!args[1]->IsString()) {
       THROW_ERR_INVALID_ARG_TYPE(env, "baseURL must be a string");
       return;
@@ -607,7 +611,7 @@ void URLPattern::Test(const FunctionCallbackInfo<Value>& args) {
   ada::url_pattern_input input;
   std::optional<std::string> baseURL{};
   std::string input_base;
-  if (args.Length() == 0) {
+  if (args.Length() == 0 || args[0]->IsNullOrUndefined()) {
     input = ada::url_pattern_init{};
   } else if (args[0]->IsString()) {
     Utf8Value input_value(env->isolate(), args[0].As<String>());
@@ -623,7 +627,7 @@ void URLPattern::Test(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  if (args.Length() > 1) {
+  if (args.Length() > 1 && !args[1]->IsNullOrUndefined()) {
     if (!args[1]->IsString()) {
       THROW_ERR_INVALID_ARG_TYPE(env, "baseURL must be a string");
       return;

test/parallel/test-urlpattern-types.js

@@ -44,3 +44,94 @@ assert.throws(() => pattern.test(1), {
 assert.throws(() => pattern.test('', 1), {
   code: 'ERR_INVALID_ARG_TYPE',
 });
+
+// Per WebIDL, undefined/null for optional arguments with defaults should use
+// the default value (empty URLPatternInit {}) rather than throwing.
+// For a union type (USVString or URLPatternInit), null resolves to the
+// dictionary branch, yielding an empty URLPatternInit.
+
+// Constructor: undefined input should be treated as empty init.
+{
+  const p = new URLPattern(undefined);
+  assert.strictEqual(p.protocol, '*');
+  assert.strictEqual(p.hostname, '*');
+}
+
+// Constructor: null input should be treated as empty init.
+{
+  const p = new URLPattern(null);
+  assert.strictEqual(p.protocol, '*');
+  assert.strictEqual(p.hostname, '*');
+}
+
+// Constructor: undefined input with undefined baseURL.
+{
+  const p = new URLPattern(undefined, undefined);
+  assert.strictEqual(p.protocol, '*');
+  assert.strictEqual(p.pathname, '*');
+}
+
+// Constructor: null input with null baseURL.
+{
+  const p = new URLPattern(null, null);
+  assert.strictEqual(p.protocol, '*');
+  assert.strictEqual(p.pathname, '*');
+}
+
+// Constructor: valid input with undefined options.
+{
+  const p = new URLPattern({ pathname: '/foo' }, undefined);
+  assert.strictEqual(p.pathname, '/foo');
+}
+
+// Constructor: valid input with null options.
+{
+  const p = new URLPattern({ pathname: '/foo' }, null);
+  assert.strictEqual(p.pathname, '/foo');
+}
+
+// Constructor: string input, undefined baseURL, undefined options.
+{
+  const p = new URLPattern('https://example.com/foo', undefined, undefined);
+  assert.strictEqual(p.hostname, 'example.com');
+  assert.strictEqual(p.pathname, '/foo');
+}
+
+// Constructor: string input, null baseURL, null options.
+{
+  const p = new URLPattern('https://example.com/foo', null, null);
+  assert.strictEqual(p.hostname, 'example.com');
+  assert.strictEqual(p.pathname, '/foo');
+}
+
+// exec() and test(): undefined input should be treated as empty init.
+{
+  const p = new URLPattern();
+  assert.strictEqual(p.test(undefined), true);
+  assert.strictEqual(p.test(undefined, undefined), true);
+  assert.notStrictEqual(p.exec(undefined), null);
+  assert.notStrictEqual(p.exec(undefined, undefined), null);
+}
+
+// exec() and test(): null input should be treated as empty init.
+{
+  const p = new URLPattern();
+  assert.strictEqual(p.test(null), true);
+  assert.strictEqual(p.test(null, null), true);
+  assert.notStrictEqual(p.exec(null), null);
+  assert.notStrictEqual(p.exec(null, null), null);
+}
+
+// exec() and test(): valid input with undefined baseURL.
+{
+  const p = new URLPattern({ protocol: 'https' });
+  assert.strictEqual(p.test('https://example.com', undefined), true);
+  assert.notStrictEqual(p.exec('https://example.com', undefined), null);
+}
+
+// exec() and test(): valid input with null baseURL.
+{
+  const p = new URLPattern({ protocol: 'https' });
+  assert.strictEqual(p.test('https://example.com', null), true);
+  assert.notStrictEqual(p.exec('https://example.com', null), null);
+}