![Três telefones, só o terceiro tocado; ao remover o segundo, FormArray e lista de objetos levam o estado junto com o 333, e string[] deixa o estado na posição.](/_next/image?url=https%3A%2F%2Fblog-dev-apps.s3.sa-east-1.amazonaws.com%2Fblog-media%2F2026-11%2F4487738d-ac05-47cd-b06e-839e41bceaad-blog-signal-forms-pt.png&w=3840&q=90)
Migrar Reactive Forms para Signal Forms no Angular 22, um pedaço de cada vez
Na última etapa da migração para Signal Forms, os 12 testes do formulário de cadastro passaram. E a versão tinha um bug: com três telefones na lista, remover o segundo fazia sumir a mensagem de erro do terceiro.
O teste da lista digitava nos três telefones antes de remover um. Com os três marcados como tocados, não fazia diferença a quem pertencia o estado de "tocado". Em Reactive Forms, ele pertence ao FormControl, que muda de posição junto com o valor. Em Signal Forms, numa lista de strings, ele fica preso à posição.
Esse foi o achado mais traiçoeiro de uma migração que eu fiz de propósito, num formulário montado com as partes que costumam travar uma migração, em quatro etapas e com a mesma suíte de testes rodando em todas. Tudo abaixo saiu desse projeto, no Angular 22.2.3.
O formulário e o que o CLI gerou
O projeto nasceu de npx -y @angular/cli@22.2.3 new com --defaults, a versão mais recente do CLI em 20/10/2026. O que veio pronto diz bastante sobre o Angular 22: nenhum zone.js no package.json (zoneless é o padrão), testes com Vitest 5 e jsdom pelo builder @angular/build:unit-test, e TypeScript ~6.0.2, embora o TypeScript 7.0.2 esteja no npm desde julho. Na declaração de ChangeDetectionStrategy do @angular/core 22.2.3 está escrito "OnPush is enabled by default". Reactive Forms funcionou sem nenhum ajuste nesse modo, inclusive a mensagem do validador assíncrono, que só chega depois da resposta HTTP. Tirei a página de boas-vindas e o router que o --defaults cria, para o bundle medir basicamente o formulário.
O formulário é um cadastro com estas partes:
- um grupo aninhado (endereço: rua, cidade, CEP);
- uma lista dinâmica de telefones, num
FormArray; - um controle customizado de telefone, com
ControlValueAccessor, que mostra(11) 98765-4321e guarda só os dígitos; - validação entre campos (confirmação de senha);
- validador assíncrono que pergunta a um endpoint se o e-mail está livre, com debounce;
- nome da empresa, que só fica habilitado para conta empresarial;
- envio que recebe 422 com erros por campo (
"address.postalCode") e os devolve para os campos; - rascunho salvo com debounce a cada mudança, sem as senhas, e restaurado ao abrir.
A suíte só toca o DOM e a camada HTTP: digita nos inputs, dispara blur, clica em botões, lê o texto das mensagens e responde as requisições pelo HttpTestingController. Nenhum teste lê form.controls ou form.valid. É isso que permite rodar a mesma suíte antes, durante e depois da migração (com dois ajustes, que aparecem mais abaixo). Um teste que olha para dentro do FormGroup morre na primeira etapa.
Etapa 1: o controle customizado troca de contrato
O controle de telefone era um ControlValueAccessor clássico: provider de NG_VALUE_ACCESSOR com forwardRef, writeValue, registerOnChange, registerOnTouched, setDisabledState e dois callbacks guardados em campos privados. Em Signal Forms, o contrato é FormValueControl, e o único membro obrigatório é um model() chamado value (abaixo, o componente sem a função formatPhone):
import { Component, computed, input, model, output } from '@angular/core';
import { FormValueControl } from '@angular/forms/signals';
@Component({
selector: 'app-phone-input',
template: `
<input
type="tel"
[attr.aria-label]="label()"
[value]="display()"
[disabled]="disabled()"
(input)="onInput($event)"
(blur)="touch.emit()"
/>
`,
})
export class PhoneInput implements FormValueControl<string> {
/** O único membro obrigatório do contrato: o formulário mantém em sincronia. */
readonly value = model('');
readonly disabled = input(false);
readonly touch = output<void>();
readonly label = input('Phone');
protected readonly display = computed(() => formatPhone(this.value()));
protected onInput(event: Event): void {
const el = event.target as HTMLInputElement;
const digits = el.value.replace(/\D/g, '').slice(0, 11);
el.value = formatPhone(digits);
this.value.set(digits);
}
}
O formulário não mudou uma linha. O template continuou com <app-phone-input [formControlName]="i" /> dentro do formArrayName, e o componente não tem mais nenhum ControlValueAccessor. Quem liga os dois é o próprio NgControl do Reactive Forms: no .d.ts do 22.2.3 ele tem um modo de "custom control" que liga valor, disabled, touched e erros direto nos inputs do componente. A página de migração diz que um controle assim funciona em formulários reativos e template-driven sem mudança, e pede para não implementar as duas interfaces no mesmo componente.
Para conferir, escrevi um teste do controle dentro de um FormGroup comum, ligado por formControlName: valor formatado na entrada, dígitos no FormControl ao digitar, touched no blur, e setValue(), disable() e enable() chamados pelo código refletindo no input. Os quatro testes passaram com o ControlValueAccessor e passaram, sem alteração, com o FormValueControl. O arquivo do componente caiu de 50 para 36 linhas.
Essa etapa é independente do resto. Dá para fazê-la num controle usado por muitos formulários reativos sem migrar nenhum deles.
Etapa 2: uma seção vira Signal Forms dentro do FormGroup
A camada de compatibilidade existe e mora em @angular/forms/signals/compat. Ela vai nos dois sentidos. SignalFormControl é um AbstractControl com regras de Signal Forms por dentro, que entra num FormGroup existente. compatForm é o contrário: um formulário de Signal Forms cujo modelo pode conter FormControls reativos. As duas estão marcadas @publicApi 22.0 nos tipos do pacote.
Migrei o endereço com SignalFormControl, mantendo o FormGroup raiz (trecho, sem os outros campos):
// Seção migrada: regras de Signal Forms, ainda um controle dentro do FormGroup reativo.
// Declarado à parte porque o FormBuilder o tipa como AbstractControl e perde o fieldTree.
private readonly addressControl = new SignalFormControl<Address>({ street: '', city: '', postalCode: '' }, (address) => {
required(address.street);
required(address.city);
required(address.postalCode);
pattern(address.postalCode, POSTAL_CODE, { message: messageFor('postalCode') });
// SignalFormControl.setErrors() lança erro: o erro do servidor precisa virar uma regra.
validate(address.postalCode, ({ value }) => {
const error = this.addressServerErrors().postalCode;
return error && error.value === value() ? { kind: 'server', message: error.message } : null;
});
});
protected readonly form = this.fb.group(
{
// ...os outros campos, iguais
address: this.addressControl,
phones: this.fb.array([this.phoneControl()]),
},
{ validators: passwordsMatch },
);
/** O FieldTree da seção, para o [formField] no template. */
protected readonly address = this.addressControl.fieldTree;
No template, os três inputs trocaram formControlName por [formField]="address.street". O resto do formulário continuou reativo, e os 16 testes passaram. No caminho apareceram quatro diferenças.
A primeira é de tipo. Com o SignalFormControl declarado direto dentro do fb.group({...}), o build falhou:
TS2339: Property 'fieldTree' does not exist on type 'AbstractControl<any, any, any>'.
O tipo do FormBuilder reconhece FormControl, FormGroup, FormRecord e FormArray; qualquer outra subclasse cai no caso genérico de AbstractControl. Declarar o controle num campo próprio da classe resolve.
A segunda é que, para o lado reativo, a seção virou uma folha. form.get('address') existe, form.get('address.postalCode') devolve null. O código que pegava o 422 e fazia this.form.get(field)?.setErrors(...) para cada erro não acha mais o CEP, e precisou de um desvio para a seção.
A terceira explica o código acima. A API imperativa do AbstractControl não funciona nessa classe. Chamei três métodos num teste à parte e os três lançaram erro:
SignalFormControl.setErrors(): NG01920: Imperatively setting errors is not supported in signal forms. Errors are derived from validation rules.
SignalFormControl.disable(): NG01920: Imperatively changing enabled/disabled status in form control is not supported in signal forms. Instead use a "disabled" rule to derive the disabled status from a signal.
SignalFormControl.setValidators(): NG01920: Dynamically adding and removing validators is not supported in signal forms. Instead use the "applyWhen" rule to conditionally apply validators based on a signal.
Então o erro do servidor virou uma regra: um signal guarda a mensagem junto com o valor que o servidor recusou, e o validate só reporta o erro enquanto o campo tiver aquele valor. Quando o usuário edita o CEP, o erro some, que é o mesmo comportamento do setErrors no Reactive Forms (os validadores rodam de novo na mudança e sobrescrevem o erro manual).
A quarta é uma boa notícia: markAllAsTouched() e patchValue() chamados no FormGroup raiz chegaram aos campos de dentro do SignalFormControl. O envio vazio mostrou "Required" na rua, na cidade e no CEP, e o rascunho restaurado preencheu o endereço.
O outro sentido: compatForm
Não usei compatForm no formulário, só em testes isolados, para saber como ele se comporta com um FormControl reativo dentro do modelo (código simplificado):
const email = new FormControl('ada@', { nonNullable: true, validators: Validators.email });
const model = signal({ name: 'Ada', email });
const f = TestBed.runInInjectionContext(() => compatForm(model, (p) => required(p.name)));
expect(f.email().value()).toBe('ada@');
expect(f().value().email).toBe(email); // o valor inteiro guarda o próprio FormControl
expect(extractValue(f)).toEqual({ name: 'Ada', email: 'ada@' });
const [error] = f.email().errors(); // um CompatValidationError
expect(error.kind).toBe('email');
Os erros do validador reativo aparecem como CompatValidationError, com o kind igual à chave do Reactive Forms (email, e emailTaken no teste com validador assíncrono). O valor do formulário inteiro carrega o objeto FormControl, e extractValue devolve os valores crus.
A escolha entre os dois, na minha leitura: SignalFormControl quando o FormGroup raiz é usado por outro código (um componente pai que recebe o grupo, um serviço que chama patchValue) e uma seção pode mudar sem que ninguém de fora perceba. compatForm quando o formulário em si pode mudar, mas um pedaço tem lógica em RxJS que não compensa portar agora, como um validador assíncrono complicado.
Etapa 3: o formulário inteiro
A última etapa troca o FormGroup por um signal com o modelo e uma função de schema com as regras:
protected readonly model = signal<SignupModel>(this.initialModel());
protected readonly form = form(
this.model,
(p) => {
required(p.name);
required(p.email);
email(p.email);
validateHttp(p.email, {
request: ({ value }) => ({ url: '/api/check-email', params: { email: value() } }),
debounce: this.timing.emailCheckDebounceMs,
onSuccess: (result: { available: boolean }) => (result.available ? null : { kind: 'emailTaken' }),
onError: () => null, // uma checagem que falhou não pode travar o usuário
});
required(p.password);
minLength(p.password, 8);
required(p.confirmPassword);
validate(p.confirmPassword, ({ value, valueOf }) =>
value() && valueOf(p.password) && value() !== valueOf(p.password) ? { kind: 'passwordMismatch' } : null,
);
disabled(p.companyName, { when: ({ valueOf }) => valueOf(p.accountType) !== 'business' });
required(p.companyName);
required(p.address.street);
required(p.address.city);
required(p.address.postalCode);
pattern(p.address.postalCode, POSTAL_CODE, { message: messageFor('postalCode') });
applyEach(p.phones, (phone) => {
required(phone.number);
pattern(phone.number, PHONE, { message: messageFor('phone') });
});
},
{
submission: {
action: (f) => this.send(f),
// O padrão, 'pending', envia com a checagem de e-mail ainda rodando.
ignoreValidators: 'none',
},
},
);
No template, <form [formGroup]="form" (ngSubmit)="submit()" novalidate> virou <form [formRoot]="form"> (a diretiva FormRoot põe o novalidate sozinha), cada formControlName="x" virou [formField]="form.x", e o botão passou a ler form().submitting().
Várias peças do código reativo sumiram, e cada uma trocou mecanismo:
- A assinatura em
accountType.valueChangesque chamavaenable()edisable()no nome da empresa virou a regradisabled(..., { when }). Uma observação: passar a função direto,disabled(path, fn), ainda compila, mas está marcado como@deprecatedno 22.2; a forma atual é o objeto comwhen. - O validador de grupo
passwordsMatchvirou umvalidateno próprio campo de confirmação. No Reactive Forms, o erro morava no grupo, e o template precisava de um método que juntasse o erro do grupo com os erros do campo. Agora ele é só mais um erro do campo. - O validador assíncrono com
timer+switchMap(o debounce tinha que viver dentro do validador, porque o Reactive Forms desassina o Observable anterior a cada tecla) virouvalidateHttpcom a opçãodebounce. O teste que digita dois e-mails seguidos e espera uma requisição só, com o último, passou nas duas versões. - A restauração do rascunho, que precisava esvaziar o
FormArraye recriar umFormControlpor telefone antes dopatchValue(opatchValuenão aumenta umFormArray), virou o valor inicial do signal. - O loop que chamava
setErrorspara cada erro do 422 virou o retorno daaction: uma lista de{ kind, message, fieldTree }, e o Signal Forms pendura cada erro no campo certo e o limpa quando o usuário edita aquele campo, como diz a página de envio.
O envio ficou assim:
private async send(f: FieldTree<SignupModel>) {
const { confirmPassword, companyName, phones, ...rest } = f().value();
// O modelo mantém companyName enquanto o campo está desabilitado: tirar do payload agora é explícito.
const request = {
...rest,
...(rest.accountType === 'business' && { companyName }),
phones: phones.map((p) => p.number),
};
try {
await firstValueFrom(this.http.post('/api/signup', request));
this.created.set(true);
this.drafts.clear();
return null;
} catch (err) {
if (!(err instanceof HttpErrorResponse) || err.status !== 422) throw err;
// Não existe form.get('address.postalCode'): o caminho é percorrido pelas chaves do FieldTree.
return (err.error.errors as ServerFieldError[]).map(({ field, message }) => ({
kind: 'server',
message,
fieldTree: field.split('.').reduce((node: any, key) => node[key], f) as FieldTree<unknown>,
}));
}
}
A primeira execução da suíte contra essa versão teve 5 falhas em 12. Quatro vinham do jeito como os testes esperavam a tela. Uma era comportamento.
O que não mapeou um para um
Enviar com a checagem de e-mail em andamento
O teste digita um e-mail novo, clica em enviar antes de a checagem de disponibilidade responder e espera que nenhum POST saia. No Reactive Forms, o submit() tinha if (this.form.invalid || this.form.pending) return;. Em Signal Forms, o envio saiu:
Error: Expected zero matching requests for criteria "Match method: POST, URL: /api/signup", found 1.
É o padrão documentado. FormSubmitOptions.ignoreValidators aceita 'pending', 'none' ou 'all', e o padrão é 'pending': validadores pendentes não bloqueiam o envio. A página de operações assíncronas avisa que o submit() não espera a validação assíncrona. Com ignoreValidators: 'none', o teste passou. Num formulário em que o servidor valida de novo de qualquer jeito, o padrão pode ser aceitável. No meu, mandar o cadastro antes de saber se o e-mail existe era exatamente o que o código reativo evitava.
A lista de strings e o estado que fica na posição
Na primeira versão da etapa 3, phones era string[], como no FormArray. Os 12 testes passaram depois do ajuste acima, e o bug da abertura estava lá. Escrevi um teste isolado com três itens, só o terceiro marcado como tocado, removendo o segundo:
it('Signal Forms, array of strings', () => {
const model = signal({ phones: ['111', '222', '333'] });
const f = TestBed.runInInjectionContext(() => form(model));
f.phones[2]().markAsTouched();
model.update((m) => ({ phones: m.phones.filter((_, i) => i !== 1) }));
const state = [...f.phones].map((p) => [p().value(), p().touched()]);
console.log('strings:', JSON.stringify(state));
});
Com o mesmo teste para uma lista de objetos ({ number: '111' }) e para um FormArray:
strings: [["111",false],["333",false]]
objects: [["111",false],["333",true]]
No FormArray, o resultado foi ['333', true], porque o FormControl inteiro muda de posição. Numa lista de strings em Signal Forms, o "333" foi para a posição 1 e herdou o estado da posição 1, que nunca foi tocada. Numa lista de objetos, o estado acompanhou o item. A página de modelos diz que itens de array que são objetos recebem uma identidade de rastreamento automaticamente; sobre primitivos ela não diz nada.
Na tela, o efeito é a mensagem de erro sumir de um telefone inválido depois que o usuário remove outro. A correção foi mudar o modelo para phones: { number: string }[], ligar [formField]="phone.number", usar track phone no @for e converter para string[] no payload e no rascunho. E a suíte ganhou o teste que faltava: só o terceiro telefone tocado, remove o segundo, a mensagem tem que estar na posição 1. Ele falhou com string[] e passou com objetos.
whenStable() que não volta
Das quatro falhas restantes, duas foram timeout de 5 segundos e duas foram asserts feitos cedo demais. A suíte esperava a tela com await fixture.whenStable(). Com validateHttp, a checagem de e-mail é um httpResource, e o ResourceImpl do @angular/core 22.2.3 registra uma tarefa em PendingTasks enquanto carrega. Para o Angular, a aplicação não está estável enquanto a requisição não volta; e no teste ela só volta quando o próprio teste chama flush(), que vinha depois do await. O teste esperava a resposta que ele mesmo ainda ia mandar.
As outras duas passam pela action do envio, que é async: o created.set(true) e os erros do 422 só acontecem depois que a promise do POST resolve. Minha leitura, que não instrumentei, é que o whenStable() devolvia o controle antes disso. Troquei o helper:
// Não fixture.whenStable(): um httpResource em andamento (validateHttp) é uma pending task,
// e whenStable() esperaria uma resposta que o teste ainda não enviou.
// Uma macrotask deixa as cadeias de promise (a action async do envio) terminarem, depois renderiza.
const stable = async () => {
await sleep(0);
TestBed.tick();
};
Essa foi uma das duas mudanças no arquivo de testes durante a migração. A outra foi o teste novo da lista. Rodei a suíte final, com os dois, contra o código das etapas 0, 1 e 2: 17 de 17 em todas.
As diferenças menores
| No Reactive Forms | Em Signal Forms 22.2 | O que eu fiz |
|---|---|---|
form.value deixa de fora controles desabilitados | value() mantém companyName: '' com o campo desabilitado; com o payload ingênuo, o teste do POST falhou mostrando esse campo a mais | payload montado explicitamente |
form.get('address.postalCode') | não existe | field.split('.').reduce(...) sobre o FieldTree |
valueChanges | não existe; toObservable(model) emite o valor atual na primeira vez | skip(1); sem ele, um rascunho vazio era salvo ao abrir a tela |
erro minlength | erro minLength | messageFor aceita os dois |
classes ng-pristine, ng-invalid, ng-touched no input | nenhuma (no Chromium, o #name ficou sem atributo class) | provideSignalFormsConfig({ classes: NG_STATUS_CLASSES }) devolve as três, por 0,35 kB a mais no chunk cru |
O rascunho era a assinatura em valueChanges com debounceTime, e valueChanges é uma das fontes que nunca completam que eu citei no post de RxJS medido. Ele virou:
// Signal Forms não tem valueChanges. toObservable emite o valor atual primeiro: pular.
toObservable(this.model)
.pipe(skip(1), map(toDraft), debounceTime(this.timing.draftDebounceMs), takeUntilDestroyed())
.subscribe((draft) => this.drafts.save(draft));
O @angular/core 22 tem uma função debounced() que faria isso sem RxJS, mas ela está marcada @experimental 22.0. Para debounce de efeito colateral, mantive o RxJS.
Quanto custou no bundle
Cada etapa gerou um build de produção (ng build). Medi o chunk inicial cru, com gzip nível 9 e com brotli qualidade 11, num script que lê o arquivo do dist/. O "Estimated transfer size" que o CLI imprime bateu com o brotli nos quatro builds, até a última casa decimal que ele mostra; essa coluna do ng build é brotli.
| Etapa | Chunk inicial | gzip -9 | brotli 11 | Linhas de código | Assinaturas manuais |
|---|---|---|---|---|---|
| 0. Reactive Forms | 213,4 kB | 65,4 kB | 58,3 kB | 320 | 3 |
1. controle com FormValueControl | 214,6 kB | 65,8 kB | 58,6 kB | 306 | 3 |
2. endereço com SignalFormControl | 267,8 kB | 81,0 kB | 71,4 kB | 326 | 3 |
| 3. Signal Forms inteiro | 247,3 kB | 77,8 kB | 68,3 kB | 318 | 1 |
As linhas são as não vazias e sem comentário dos cinco arquivos do formulário (componente, template, controle de telefone, validadores, modelo). As assinaturas são as chamadas a .subscribe( no componente: na etapa 0, accountType.valueChanges, form.valueChanges e o POST; na 3, só o rascunho.
A versão final ficou 10,0 kB maior em brotli que a original. O metafile do esbuild (ng build --stats-json) mostra de onde. Na etapa 0, o pacote @angular/forms ocupava 43,0 kB minificados. Na etapa 3, ocupa 62,0 kB: 14,5 kB do entry signals, 26,7 kB de um chunk de validação compartilhado e ainda 20,8 kB do entry principal, que o signals importa (NgControl, Validators, NG_VALUE_ACCESSOR, para a interoperabilidade). Além disso, validateHttp usa httpResource, e o código de resources do @angular/core e do @angular/common/http passou de 0,2 kB para 12,0 kB. O código do próprio formulário encolheu de 10,5 para 9,9 kB.
A etapa 2 é a mais cara: os dois sistemas carregados juntos, 13,1 kB de brotli acima da original. Esses números são de uma aplicação que só tem este formulário. Enquanto qualquer outro formulário da aplicação continuar reativo, o Reactive Forms continua no bundle, e o custo de cada tela migrada deve ficar mais perto da etapa 2 que da 3. Isso eu não medi.
E o código não encolheu. Foram 320 linhas antes e 318 depois. O que mudou foi o lugar: validators.ts caiu de 19 para 2 linhas, o componente subiu de 106 para 135, e 20 dessas linhas são a interface do modelo e o objeto inicial, que o FormBuilder inferia sozinho.
Os quatro builds também rodaram num Chromium 156 de verdade, pelo Playwright, com um interceptor que simula a API com 300 a 400 ms de latência: e-mail já cadastrado, telefone formatado ao digitar, erros do servidor no e-mail e no CEP, erro do CEP sumindo ao editar, cadastro criado e rascunho sobrevivendo a um reload com dois telefones. As seis checagens passaram nos quatro, sem erro no console.
Quando não vale migrar
A própria visão geral do Signal Forms diz que, numa aplicação existente com formulários reativos, eles "remain a solid choice". A API é estável: os símbolos públicos do entry estão marcados @publicApi 22.0 (fora um helper de WebMCP, experimental), e o changelog do 22.0.0 (03/06/2026) tem a entrada "graduate signal forms APIs to public API". Estável não quer dizer que a migração se paga sozinha. Na minha opinião, depois deste exercício, ela não compensa nestes casos:
Quando o formulário depende da API imperativa vinda de fora dele. Um interceptor que chama setErrors em qualquer controle, um serviço que faz addValidators conforme uma configuração remota, um componente pai que chama disable() num grupo. Durante a convivência, o SignalFormControl lança NG01920 em setErrors, disable e setValidators (os três que testei; a página de migração inclui addValidators e removeValidators), e no fim cada uso precisa virar uma regra declarada no schema. Se essa lógica está espalhada pela aplicação, a migração é dela, não do formulário.
Quando o bundle é o que importa e o formulário é o único uso de forms na página. Aqui foram 10,0 kB de brotli a mais no fim, e 13,1 kB durante a convivência.
Quando o formulário funciona e não vai mudar. A migração troca mecanismo, não diminui código (318 contra 320 linhas), e traz diferenças de comportamento que só aparecem com teste: o envio com validação pendente e o estado de lista que ficou na posição passaram despercebidos até a suíte, ou um teste novo, apontar.
Quando os testes do formulário leem form.controls e form.valid. Aí a migração reescreve os testes junto com o código, e eles deixam de ser rede. No meu caso, as duas diferenças de comportamento apareceram porque os testes eram pelo DOM e continuaram valendo nas quatro etapas.
Componentes de terceiros que só oferecem ControlValueAccessor não são, sozinhos, um motivo para esperar: a documentação da diretiva FormField diz que ela aceita um componente com ControlValueAccessor, caminho que "should only be used for backwards compatibility". Eu não testei esse caminho.
O que eu faria em qualquer projeto Angular 22 é a etapa 1. Ela é barata (50 para 36 linhas, 0,3 kB de brotli), não exige mexer em formulário nenhum e, segundo a documentação, deixa o controle pronto para Signal Forms, Reactive Forms e template-driven. Formulário novo eu começo em Signal Forms. Os existentes migram um por um, quando já iam ser mexidos, depois que a suíte deles tiver um teste que remove um item do meio de uma lista.
Não medi formulários com centenas de campos, latência de digitação, Firefox, Safari nem renderização no servidor.
Comentários
Carregando comentários...