fix(forms): correct validateAsync params parameter type inference

TypeScript's type inference for AsyncValidatorOptions was locking TParams
to a non-nullable type based on the factory function's Signal<TParams |
undefined> parameter (a higher-priority inference site), which conflicted
with the params function, whose declared return type was TParams (not
TParams | undefined). As a result, returning undefined from params to
skip a validation run - the documented and supported way to opt out of
running the async validator for a given state - was a type error.

This widens params to return TParams | undefined so its declared type
matches what it always could (and needs to) return at runtime, aligning
both inference sites and letting TParams be inferred consistently.

Fixes angular#67859

Author: surajy93

goldens/public-api/forms/signals/index.api.md

@@ -49,7 +49,7 @@ export interface AsyncValidatorOptions<TValue, TParams, TResult, TPathKind exten
     readonly factory: (params: Signal<TParams | undefined>) => Resource<TResult | undefined>;
     readonly onError: (error: unknown, ctx: FieldContext<TValue, TPathKind>) => TreeValidationResult;
     readonly onSuccess: MapToErrorsFn<TValue, TResult, TPathKind>;
-    readonly params: (ctx: FieldContext<TValue, TPathKind>) => TParams;
+    readonly params: (ctx: FieldContext<TValue, TPathKind>) => TParams | undefined;
     readonly when?: NoInfer<LogicFn<TValue, boolean, TPathKind>>;
 }
 

packages/forms/signals/src/api/rules/validation/validate_async.ts

@@ -65,11 +65,13 @@ export interface AsyncValidatorOptions<
 > {
   /**
    * A function that receives the field context and returns the params for the resource.
+   * Returning `undefined` indicates that the resource should not be run for the current state
+   * (the forms system will report the params as `undefined` to the factory's resource).
    *
    * @param ctx The field context for the field being validated.
-   * @returns The params for the resource.
+   * @returns The params for the resource, or `undefined` to skip running the resource.
    */
-  readonly params: (ctx: FieldContext<TValue, TPathKind>) => TParams;
+  readonly params: (ctx: FieldContext<TValue, TPathKind>) => TParams | undefined;
 
   /**
    * Duration in milliseconds to wait before triggering the async operation, or a function that

packages/forms/signals/test/node/resource.spec.ts

@@ -238,6 +238,49 @@ describe('resources', () => {
     expect(f[1]().errors()).toEqual([]);
   });
 
+  it('should skip async validation when params function returns undefined', async () => {
+    let factoryCallCount = 0;
+    const value = signal('');
+
+    const f = form(
+      value,
+      (p) => {
+        validateAsync(p, {
+          params: ({value}) => {
+            const v = value().trim();
+            return v ? v : undefined;
+          },
+          factory: (params) => {
+            factoryCallCount++;
+            return resource({
+              params,
+              loader: async ({params}) => params !== undefined,
+            });
+          },
+          onSuccess: (exists) => (exists ? {kind: 'value-exists'} : undefined),
+          onError: () => null,
+        });
+      },
+      {injector},
+    );
+
+    // empty value: params return undefined, resource should be idle( not pending)
+    await appRef.whenStable();
+    expect(f().pending()).toBe(false);
+    expect(f().errors()).toEqual([]);
+
+    // non-empty value: params returns a string, resource should run
+    value.set('hello');
+    await appRef.whenStable();
+    expect(f().errors()).toEqual([{kind: 'value-exists', fieldTree: f} as any]);
+
+    //back to empty: resource should go idle again, no errors
+    value.set('');
+    await appRef.whenStable();
+    expect(f().errors()).toEqual([]);
+    expect(f().pending()).toBe(false);
+  });
+
   it('should support shorthand http validation', async () => {
     const usernameForm = form(
       signal('unique-user'),