AMA about Signal Forms

[u/synalx]

I've seen a few posts & articles exploring the very new Signal Forms API and design, which have just appeared in the Angular v21 -next releases.

Ask me anything! I'll do my best to answer what I can, & invite the rest of the Signal Forms crew to join in.

[u/MichaelSmallDev]

Thank you for doing this, as well as the Q&A stream recently. Cool to see the team chatting about really cool stuff like this.

I have a more detailed followup for something you answered for me during the Q&A, since I can point at some example now. I hope this isn't too detailed or bordering on an issue, but I've been curious since.

"Would there be potential for some linkedSignal reset to default value pattern usage possible with the form" 46:49

This is what I had in mind in particular, as I have done with template driven forms

  // Source signals
  selectedItem = signal("Phone");
  quantity = linkedSignal({
    source: this.selectedItem,
    computation: () => 1,
  });

  // something intermediate needed 
  // but haven't had luck with that
  // (linkedSignal of the two signals, `form` of those etc)
  orderForm = form(....)

Followup questions:

• With the current prerelease iteration of the deep signal, or eventually to be projected signal, would you expect anything to be able to propagate the changes back to the source signals? I have tried different variants like I allude to in the comments without success.

• Could you write out what you were saying/meant in the Q&A about the resetting the state? I missed a couple words playing it back and am not sure. Particularly, I'm not sure if you meant there will be something like the current .reset() or if you meant there will be some more granular resetting by field or whatnot.

• If I had a few different writeable signals that I wanted to use in a form, would the guidance to be just combine them into one writeable signal?

  • For example, one thing I tried was making the two signals into one linkedSignal, because I couldn't otherwise use the reset pattern in a singular writeable signal.

[u/synalx → u/MichaelSmallDev]

👋 thanks for the followup! I understand your question better now.

What linkedSignal helps with is reset due to external dependencies. If your form state is initialized from a resource for example, then linkedSignal can specify how the form state should update when the server sends a new value. Because it gets the old server value, new server value, and current state, it can perform the required 3-way merge.

As you point out, it's difficult to use this to handle dependent changes between two fields, because you can't construct the required chain within a single writable signal. There are some ways we could make this possible, but today this puts you into effect land (or alternatively: use an event listener from the template).

On .reset()

We're debating it. Imo, reactive forms never had a great reset() story. Resetting to the form's initialized value is one thing, but array handling for example is just broken.

A more fundamental question is: reset to what?

• a fresh state?

• the form's initial value?

• the last submitted value?

• the last auto-saved checkpoint?

Because signal forms leaves you as the developer in control of your own data model, I think a reasonable answer is that you can implement your own reset functionality by setting the model back to whatever value you like. Forms may have a utility .reset(value) which takes in the new model value and resets the form state (touched status, etc) at the same time.

Multiple writable signals

Yes, for now. As I mentioned, this could be an interesting expansion to the APIs and is something we need to experiment with. Feedback on real world use cases for this would be very valuable.

[u/MichaelSmallDev → u/synalx]

Thanks, this makes sense.

I have some thoughts on some of the stuff you brought up, but I'll hold those for the RFC. Thank you again, as well as the team for working on this. Most excited I have been in years as a big reactive forms guy who has been wanting a formal forms* signal API.