@ryanbrandenburg can you please investigate and come up with some cost for this work? Thanks!

@danroth27 seems we rely on jQuery for our validation too, it's not just transitive because of Bootstrap dependency.

@mkArtakMSFT Right, the main work item tracked by this issue is investigating what it would take to remove the jQuery dependency from our validation support.

Given that our current validation support is built on jQuery validation, the way I would think about this issue is to take a fresh look at what our client validation support should look like. Is there a different validation library that we should consider using? Etc.

The one option that seems to be most popular (and standards compliant) would be using the built-in HTML5 form validation. The problem there is that it would only work for client-side validation. As far as I can tell HTML5 form validation doesn't solve any server-side validation problems, and even if it did it would require a lot of changes to DataAnnotations. HTML5 also isn't supported on older browsers (IE9 was the example I found).

In my opinion it's not worth the work that would be required to remove our dependencies here in the absence of a more unified vision about what value we can produce from re-working DataAnnotations.

We've moved this issue to the Backlog milestone. This means that it is not going to be worked on for the coming release. We will reassess the backlog following the current release and consider this item at that time. To learn more about our issue management process and to have better expectation regarding different types of issues you can read our Triage Process.

Moving this out of 6.0. The initial thought was that we could do something tactical building upon either browser features such as constraint validation or hand rolling a facsimile of jQuery.validation. But on further inspection, we realize that an alternative that simply removes jquery does not move the needle enough for us invest in.

https://github.com/aspnet/specs/blob/main/notes/RemoveJQueryUnobtrusiveValidation.md has some notes about our conversations around this and what we might expect if we were to consider improving this experience:

Offline notes

I think we need to start by defining the goals here, for me those are:

• Developers should be able to author great forms out of the box without writing JS code.
• Authoring more advanced forms should be an incremental process, meaning you can add/compose on top of the existing form functionality instead of rewriting the form in its entirety.
• There should be room for a progressive enhancement story, where you can author a form that can work in the context of a SPA as well as in the context of a plain server rendered app without separate solutions.
  In general, I think we would need to look at several things:
• Investigate the cost of removing jquery and jquery validate (WITHOUT) accounting for extensibility based on the current set of supported validation rules. Tell people
• My gut is that the "most complicated" to keep compat with are CreditCard, EmailAddress, Phone, and Url; and I'm not sure they matter that much, for example, Url and EmailAddress perform incredibly dumb validations in .net core (see here) so they are useless. Credit card and phone can easily be converted to equivalent JS validations.
• For things like numbers, etc. There's good support now for the Intl global that does most of the job for localized comparisons.
  • Investigate/define what experience we want to enable here around forms:
• Look at great form experiences on the web and identify what makes them great:
  • Placeholders.
  • Autofill (Phone number, credit card info, etc).
  • Validation on input/focus out.
  • Input states.
  • Dynamism (new form sections rendering in response to changes, multi-step forms/wizards, etc.)
  • Form reset.
• Identify the end-to-end scenarios for forms that we care about:
  • Vanilla MVC/Razor pages app.
  • MVC app + JS Islands.
  • MVC + SPA framework.
  • MVC + Blazor
  • Blazor.
• Identify the progressions/cut-offs for each transition:
  • What should you be able to do out of the box without writing any JS*
  • What should you be able to do with vanilla JS (no framework involved)
  • When would you need to switch to a full-blown SPA framework*
  • When you need to switch to a new approach,
  • How big are the changes you need to make*
  • Are there things from the implementation you can reuse*
  • Investigate what modern browser standards we can leverage to offer a better experience:
• Can we use the built-in HTML5 validation mechanism to implement the validation rules*
• Can we encapsulate the validation primitives in web components in a way that they can be reused across different parts of the stack and with other UI frameworks*
• What other modern HTML5 features we can leverage to offer a more complete out of the box forms experience*

@pranavkm your link to https://github.com/aspnet/specs/blob/main/notes/RemoveJQueryUnobtrusiveValidation.md is invalid

Sorry @Andrzej-W that repo is non-public, but I've updated my comment with details about what we would want from a re-design.

@pranavkm Thanks for posting those notes. I am eager to see what you can come up with in a future version

#41750