![Tres teléfonos, solo el tercero tocado; al quitar el segundo, FormArray y la lista de objetos llevan el estado con el 333, y string[] lo deja en la posición.](/_next/image?url=https%3A%2F%2Fblog-dev-apps.s3.sa-east-1.amazonaws.com%2Fblog-media%2F2026-11%2Fa442ccea-5313-4a3b-be86-829f7b06aa89-blog-signal-forms-es.png&w=3840&q=90)
Migrar Reactive Forms a Signal Forms en Angular 22, una pieza a la vez
En la última etapa de la migración a Signal Forms, los 12 tests del formulario de registro pasaron. Y esa versión tenía un bug: con tres teléfonos en la lista, quitar el segundo hacía desaparecer el mensaje de error del tercero.
El test de la lista escribía en los tres teléfonos antes de quitar uno. Con los tres marcados como tocados, daba igual a quién pertenecía el estado de "tocado". En Reactive Forms, pertenece al FormControl, que cambia de posición junto con el valor. En Signal Forms, en una lista de strings, se queda pegado a la posición.
Ese fue el hallazgo más engañoso de una migración que hice a propósito, en un formulario armado con las partes que suelen trabar una migración, en cuatro etapas y con la misma suite de tests corriendo en todas. Todo lo que sigue salió de ese proyecto, en Angular 22.2.3.
El formulario y lo que generó el CLI
El proyecto nació de npx -y @angular/cli@22.2.3 new con --defaults, la versión más reciente del CLI el 20/10/2026. Lo que viene listo dice bastante sobre Angular 22: ningún zone.js en el package.json (zoneless es el valor por defecto), tests con Vitest 5 y jsdom a través del builder @angular/build:unit-test, y TypeScript ~6.0.2, aunque TypeScript 7.0.2 está en npm desde julio. En la declaración de ChangeDetectionStrategy de @angular/core 22.2.3 dice "OnPush is enabled by default". Reactive Forms funcionó en ese modo sin ningún ajuste, incluido el mensaje del validador asíncrono, que solo llega después de la respuesta HTTP. Quité la página de bienvenida y el router que crea --defaults, para que el bundle midiera básicamente el formulario.
El formulario es un registro con estas partes:
- un grupo anidado (dirección: calle, ciudad, código postal);
- una lista dinámica de teléfonos, en un
FormArray; - un control personalizado de teléfono, con
ControlValueAccessor, que muestra(11) 98765-4321y guarda solo los dígitos; - validación entre campos (confirmación de contraseña);
- un validador asíncrono que le pregunta a un endpoint si el e-mail está libre, con debounce;
- el nombre de la empresa, habilitado solo para cuentas de empresa;
- un envío que recibe un 422 con errores por campo (
"address.postalCode") y los devuelve a los campos; - un borrador guardado con debounce en cada cambio, sin las contraseñas, y restaurado al abrir.
La suite solo toca el DOM y la capa HTTP: escribe en los inputs, dispara blur, hace clic en botones, lee el texto de los mensajes y responde las peticiones con HttpTestingController. Ningún test lee form.controls ni form.valid. Eso es lo que permite correr la misma suite antes, durante y después de la migración (con dos ajustes, que aparecen más abajo). Un test que mira dentro del FormGroup muere en la primera etapa.
Etapa 1: el control personalizado cambia de contrato
El control de teléfono era un ControlValueAccessor clásico: provider de NG_VALUE_ACCESSOR con forwardRef, writeValue, registerOnChange, registerOnTouched, setDisabledState y dos callbacks guardados en campos privados. En Signal Forms, el contrato es FormValueControl, y su único miembro obligatorio es un model() llamado value (abajo, el componente sin la función 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> {
/** El único miembro obligatorio del contrato: el formulario lo mantiene sincronizado. */
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);
}
}
El formulario no cambió ni una línea. La plantilla siguió con <app-phone-input [formControlName]="i" /> dentro del formArrayName, y el componente ya no tiene ningún ControlValueAccessor. Quien conecta los dos es el propio NgControl de Reactive Forms: en el .d.ts de la 22.2.3 tiene un modo de "custom control" que enlaza valor, disabled, touched y errores directo a los inputs del componente. La guía de migración dice que un control así funciona en formularios reactivos y template-driven sin cambios, y pide no implementar las dos interfaces en el mismo componente.
Para comprobarlo, escribí un test del control dentro de un FormGroup común, enlazado con formControlName: valor formateado al entrar, dígitos en el FormControl al escribir, touched en el blur, y setValue(), disable() y enable() llamados desde el código reflejándose en el input. Los cuatro tests pasaron con el ControlValueAccessor y pasaron, sin cambios, con el FormValueControl. El archivo del componente bajó de 50 a 36 líneas.
Esta etapa es independiente del resto. Puedes hacerla en un control usado por muchos formularios reactivos sin migrar ninguno.
Etapa 2: una sección pasa a Signal Forms dentro del FormGroup
La capa de compatibilidad existe y vive en @angular/forms/signals/compat. Va en los dos sentidos. SignalFormControl es un AbstractControl con reglas de Signal Forms adentro, que entra en un FormGroup existente. compatForm es lo contrario: un formulario de Signal Forms cuyo modelo puede contener FormControls reactivos. Los dos están marcados @publicApi 22.0 en los tipos del paquete.
Migré la dirección con SignalFormControl, manteniendo el FormGroup raíz (fragmento, sin los otros campos):
// Sección migrada: reglas de Signal Forms, todavía un control dentro del FormGroup reactivo.
// Declarado aparte porque el FormBuilder lo tipa como AbstractControl y pierde el 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() lanza un error: el error del servidor tiene que convertirse en una regla.
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(
{
// ...los otros campos, iguales
address: this.addressControl,
phones: this.fb.array([this.phoneControl()]),
},
{ validators: passwordsMatch },
);
/** El FieldTree de la sección, para el [formField] de la plantilla. */
protected readonly address = this.addressControl.fieldTree;
En la plantilla, los tres inputs cambiaron formControlName por [formField]="address.street". El resto del formulario siguió reactivo, y los 16 tests pasaron. En el camino aparecieron cuatro diferencias.
La primera es de tipos. Con el SignalFormControl declarado directamente dentro de fb.group({...}), el build falló:
TS2339: Property 'fieldTree' does not exist on type 'AbstractControl<any, any, any>'.
El tipo del FormBuilder reconoce FormControl, FormGroup, FormRecord y FormArray; cualquier otra subclase cae en el caso genérico de AbstractControl. Declarar el control en un campo propio de la clase lo resuelve.
La segunda es que, para el lado reactivo, la sección se volvió una hoja. form.get('address') existe; form.get('address.postalCode') devuelve null. El código que tomaba el 422 y hacía this.form.get(field)?.setErrors(...) para cada error ya no encuentra el código postal, y necesitó un desvío para esa sección.
La tercera explica el código de arriba. La API imperativa de AbstractControl no funciona en esta clase. Llamé tres métodos en un test aparte y los tres lanzaron error:
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.
Entonces el error del servidor se volvió una regla: un signal guarda el mensaje junto con el valor que el servidor rechazó, y el validate solo reporta el error mientras el campo tenga ese valor. Cuando el usuario edita el código postal, el error desaparece, que es lo mismo que hace setErrors en Reactive Forms (los validadores corren de nuevo con el cambio y sobrescriben el error manual).
La cuarta es una buena noticia: markAllAsTouched() y patchValue() llamados en el FormGroup raíz llegaron a los campos dentro del SignalFormControl. El envío vacío mostró "Required" en calle, ciudad y código postal, y el borrador restaurado llenó la dirección.
El otro sentido: compatForm
No usé compatForm en el formulario, solo en tests aislados, para ver cómo se comporta con un FormControl reactivo dentro del 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); // el valor completo guarda el propio FormControl
expect(extractValue(f)).toEqual({ name: 'Ada', email: 'ada@' });
const [error] = f.email().errors(); // un CompatValidationError
expect(error.kind).toBe('email');
Los errores del validador reactivo aparecen como CompatValidationError, con el kind igual a la clave de Reactive Forms (email, y emailTaken en el test con validador asíncrono). El valor del formulario completo lleva el objeto FormControl, y extractValue devuelve los valores crudos.
Cómo elegiría entre los dos: SignalFormControl cuando el FormGroup raíz lo usa otro código (un componente padre que recibe el grupo, un servicio que llama a patchValue) y una sección puede cambiar sin que nadie de afuera lo note. compatForm cuando el formulario en sí puede cambiar, pero una pieza tiene lógica en RxJS que no vale la pena portar ahora, como un validador asíncrono complicado.
Etapa 3: el formulario completo
La última etapa reemplaza el FormGroup por un signal con el modelo y una función de schema con las reglas:
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, // una comprobación que falló no puede bloquear al usuario
});
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),
// El valor por defecto, 'pending', envía con la comprobación de e-mail todavía corriendo.
ignoreValidators: 'none',
},
},
);
En la plantilla, <form [formGroup]="form" (ngSubmit)="submit()" novalidate> pasó a <form [formRoot]="form"> (la directiva FormRoot agrega el novalidate sola), cada formControlName="x" pasó a [formField]="form.x", y el botón ahora lee form().submitting().
Varias piezas del código reactivo desaparecieron, y cada una cambió de mecanismo:
- La suscripción a
accountType.valueChangesque llamaba aenable()ydisable()en el nombre de la empresa se volvió la regladisabled(..., { when }). Un detalle: pasar la función directo,disabled(path, fn), todavía compila, pero está marcado como@deprecateden la 22.2; la forma actual es el objeto conwhen. - El validador de grupo
passwordsMatchse volvió unvalidateen el propio campo de confirmación. En Reactive Forms, el error vivía en el grupo, y la plantilla necesitaba un método que juntara el error del grupo con los errores del campo. Ahora es un error más del campo. - El validador asíncrono con
timer+switchMap(el debounce tenía que vivir dentro del validador, porque Reactive Forms cancela la suscripción al Observable anterior en cada tecla) se volvióvalidateHttpcon la opcióndebounce. El test que escribe dos e-mails seguidos y espera una sola petición, con el último, pasó en las dos versiones. - La restauración del borrador, que tenía que vaciar el
FormArrayy crear unFormControlpor teléfono antes delpatchValue(patchValueno agranda unFormArray), se volvió el valor inicial del signal. - El bucle que llamaba a
setErrorspor cada error del 422 se volvió el valor de retorno de laaction: una lista de{ kind, message, fieldTree }. Signal Forms cuelga cada error en el campo correcto y lo limpia cuando el usuario edita ese campo, como dice la guía de envío.
El envío quedó así:
private async send(f: FieldTree<SignupModel>) {
const { confirmPassword, companyName, phones, ...rest } = f().value();
// El modelo mantiene companyName mientras el campo está deshabilitado: sacarlo del payload ahora es 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;
// No existe form.get('address.postalCode'): el camino se recorre por las claves del 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>,
}));
}
}
La primera ejecución de la suite contra esta versión tuvo 5 fallos de 12. Cuatro venían de cómo los tests esperaban la pantalla. Uno era comportamiento.
Lo que no mapeó uno a uno
Enviar con la comprobación de e-mail en curso
El test escribe un e-mail nuevo, hace clic en enviar antes de que responda la comprobación de disponibilidad y espera que no salga ningún POST. En Reactive Forms, el submit() tenía if (this.form.invalid || this.form.pending) return;. En Signal Forms, el envío salió:
Error: Expected zero matching requests for criteria "Match method: POST, URL: /api/signup", found 1.
Es el valor por defecto documentado. FormSubmitOptions.ignoreValidators acepta 'pending', 'none' o 'all', y el valor por defecto es 'pending': los validadores pendientes no bloquean el envío. La guía de operaciones asíncronas avisa que submit() no espera la validación asíncrona. Con ignoreValidators: 'none', el test pasó. En un formulario donde el servidor valida todo de nuevo de todos modos, el valor por defecto puede estar bien. En el mío, mandar el registro antes de saber si el e-mail existe era justo lo que el código reactivo evitaba.
La lista de strings y el estado que se queda en la posición
En la primera versión de la etapa 3, phones era string[], como en el FormArray. Los 12 tests pasaron después del ajuste de arriba, y el bug del comienzo estaba ahí. Escribí un test aislado con tres ítems, solo el tercero tocado, quitando el 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));
});
Con el mismo test para una lista de objetos ({ number: '111' }) y para un FormArray:
strings: [["111",false],["333",false]]
objects: [["111",false],["333",true]]
En el FormArray, el resultado fue ['333', true], porque el FormControl entero cambia de posición. En una lista de strings en Signal Forms, el "333" pasó a la posición 1 y heredó el estado de la posición 1, que nunca fue tocada. En una lista de objetos, el estado acompañó al ítem. La guía de modelos dice que los ítems de un array que son objetos reciben una identidad de seguimiento automáticamente; sobre primitivos no dice nada.
En pantalla, el efecto es que el mensaje de error desaparece de un teléfono inválido después de que el usuario quita otro. La corrección fue cambiar el modelo a phones: { number: string }[], enlazar [formField]="phone.number", usar track phone en el @for y convertir a string[] en el payload y en el borrador. Y la suite ganó el test que le faltaba: solo el tercer teléfono tocado, se quita el segundo, el mensaje tiene que estar en la posición 1. Falló con string[] y pasó con objetos.
whenStable() que nunca vuelve
De los cuatro fallos restantes, dos fueron timeouts de 5 segundos y dos fueron asserts hechos demasiado pronto. La suite esperaba la pantalla con await fixture.whenStable(). Con validateHttp, la comprobación de e-mail es un httpResource, y ResourceImpl de @angular/core 22.2.3 registra una tarea en PendingTasks mientras carga. Para Angular, la aplicación no está estable mientras la petición no vuelve; y en el test solo vuelve cuando el propio test llama a flush(), que venía después del await. El test esperaba una respuesta que él mismo todavía iba a mandar.
Los otros dos pasan por la action del envío, que es async: el created.set(true) y los errores del 422 solo ocurren después de que la promise del POST se resuelve. Mi lectura, que no instrumenté, es que whenStable() devolvía el control antes de eso. Cambié el helper:
// No fixture.whenStable(): un httpResource en curso (validateHttp) es una pending task,
// y whenStable() esperaría una respuesta que el test todavía no envió.
// Una macrotask deja terminar las cadenas de promises (la action async del envío) y luego renderiza.
const stable = async () => {
await sleep(0);
TestBed.tick();
};
Ese fue uno de los dos cambios en el archivo de tests durante la migración. El otro fue el test nuevo de la lista. Corrí la suite final, con los dos, contra el código de las etapas 0, 1 y 2: 17 de 17 en todas.
Las diferencias menores
| En Reactive Forms | En Signal Forms 22.2 | Qué hice |
|---|---|---|
form.value deja fuera los controles deshabilitados | value() mantiene companyName: '' con el campo deshabilitado; con el payload ingenuo, el test del POST falló mostrando ese campo de más | payload armado explícitamente |
form.get('address.postalCode') | no existe | field.split('.').reduce(...) sobre el FieldTree |
valueChanges | no existe; toObservable(model) emite el valor actual la primera vez | skip(1); sin él, se guardaba un borrador vacío al abrir la pantalla |
error minlength | error minLength | messageFor acepta los dos |
clases ng-pristine, ng-invalid, ng-touched en el input | ninguna (en Chromium, #name quedó sin atributo class) | provideSignalFormsConfig({ classes: NG_STATUS_CLASSES }) devuelve las tres, por 0,35 kB más en el chunk crudo |
El borrador era una suscripción a valueChanges con debounceTime, y valueChanges es una de las fuentes que nunca completan que mencioné en el post de RxJS medido. Quedó así:
// Signal Forms no tiene valueChanges. toObservable emite primero el valor actual: saltarlo.
toObservable(this.model)
.pipe(skip(1), map(toDraft), debounceTime(this.timing.draftDebounceMs), takeUntilDestroyed())
.subscribe((draft) => this.drafts.save(draft));
@angular/core 22 tiene una función debounced() que haría esto sin RxJS, pero está marcada @experimental 22.0. Para el debounce de un efecto secundario, me quedé con RxJS.
Cuánto costó en el bundle
Cada etapa generó un build de producción (ng build). Medí el chunk inicial crudo, con gzip nivel 9 y con brotli calidad 11, con un script que lee el archivo de dist/. El "Estimated transfer size" que imprime el CLI coincidió con el brotli en los cuatro builds, hasta el último decimal que muestra; esa columna de ng build es brotli.
| Etapa | Chunk inicial | gzip -9 | brotli 11 | Líneas de código | Suscripciones manuales |
|---|---|---|---|---|---|
| 0. Reactive Forms | 213,4 kB | 65,4 kB | 58,3 kB | 320 | 3 |
1. control con FormValueControl | 214,6 kB | 65,8 kB | 58,6 kB | 306 | 3 |
2. dirección con SignalFormControl | 267,8 kB | 81,0 kB | 71,4 kB | 326 | 3 |
| 3. Signal Forms completo | 247,3 kB | 77,8 kB | 68,3 kB | 318 | 1 |
Las líneas son las no vacías y sin comentarios de los cinco archivos del formulario (componente, plantilla, control de teléfono, validadores, modelo). Las suscripciones son las llamadas a .subscribe( en el componente: en la etapa 0, accountType.valueChanges, form.valueChanges y el POST; en la 3, solo el borrador.
La versión final quedó 10,0 kB más grande en brotli que la original. El metafile de esbuild (ng build --stats-json) muestra de dónde. En la etapa 0, el paquete @angular/forms ocupaba 43,0 kB minificados. En la etapa 3, ocupa 62,0 kB: 14,5 kB del entry signals, 26,7 kB de un chunk de validación compartido y todavía 20,8 kB del entry principal, que signals importa (NgControl, Validators, NG_VALUE_ACCESSOR, para la interoperabilidad). Además, validateHttp usa httpResource, y el código de resources de @angular/core y de @angular/common/http pasó de 0,2 kB a 12,0 kB. El código del propio formulario bajó de 10,5 a 9,9 kB.
La etapa 2 es la más cara: los dos sistemas cargados juntos, 13,1 kB de brotli por encima de la original. Estos números son de una aplicación que solo tiene este formulario. Mientras cualquier otro formulario de la aplicación siga siendo reactivo, Reactive Forms sigue en el bundle, y el costo de cada pantalla migrada debería quedar más cerca de la etapa 2 que de la 3. Eso no lo medí.
Y el código no se achicó. Eran 320 líneas antes y 318 después. Lo que cambió fue el lugar: validators.ts bajó de 19 a 2 líneas, el componente subió de 106 a 135, y 20 de esas líneas son la interfaz del modelo y el objeto inicial, que el FormBuilder infería solo.
Los cuatro builds también corrieron en un Chromium 156 real, con Playwright, con un interceptor que simula la API con 300 a 400 ms de latencia: e-mail ya registrado, teléfono formateado al escribir, errores del servidor en el e-mail y en el código postal, el error del código postal desapareciendo al editar, cuenta creada y borrador sobreviviendo a un reload con dos teléfonos. Las seis comprobaciones pasaron en los cuatro, sin errores en la consola.
Cuándo no vale la pena migrar
La propia visión general de Signal Forms dice que, en una aplicación existente con formularios reactivos, estos "remain a solid choice". La API es estable: los símbolos públicos del entry están marcados @publicApi 22.0 (salvo un helper de WebMCP, experimental), y el changelog de la 22.0.0 (03/06/2026) tiene la entrada "graduate signal forms APIs to public API". Estable no significa que la migración se pague sola. En mi opinión, después de este ejercicio, no compensa en estos casos:
Cuando el formulario depende de la API imperativa desde fuera de él. Un interceptor que llama a setErrors en cualquier control, un servicio que llama a addValidators según una configuración remota, un componente padre que llama a disable() en un grupo. Mientras los dos sistemas conviven, SignalFormControl lanza NG01920 en setErrors, disable y setValidators (los tres que probé; la guía de migración incluye addValidators y removeValidators), y al final cada uso tiene que convertirse en una regla declarada en el schema. Si esa lógica está repartida por la aplicación, la migración es de ella, no del formulario.
Cuando lo que importa es el bundle y el formulario es el único uso de forms en la página. Aquí fueron 10,0 kB de brotli más al final, y 13,1 kB durante la convivencia.
Cuando el formulario funciona y no va a cambiar. La migración cambia el mecanismo, no reduce código, y trae diferencias de comportamiento que solo aparecen con tests: el envío con validación pendiente y el estado de la lista que se quedó en la posición pasaron desapercibidos hasta que la suite, o un test nuevo, los señaló.
Cuando los tests del formulario leen form.controls y form.valid. Ahí la migración reescribe los tests junto con el código, y dejan de ser red de seguridad. En mi caso, las dos diferencias de comportamiento aparecieron porque los tests iban por el DOM y siguieron valiendo en las cuatro etapas.
Los componentes de terceros que solo ofrecen ControlValueAccessor no son, por sí solos, un motivo para esperar: la documentación de la directiva FormField dice que acepta un componente con ControlValueAccessor, camino que "should only be used for backwards compatibility". No probé ese camino.
Lo que haría en cualquier proyecto Angular 22 es la etapa 1. Es barata (de 50 a 36 líneas, 0,3 kB de brotli), no exige tocar ningún formulario y, según la documentación, deja el control listo para Signal Forms, Reactive Forms y template-driven. Los formularios nuevos los empiezo en Signal Forms. Los existentes se migran de a uno, cuando de todos modos iban a tocarse, después de que su suite tenga un test que quite un ítem del medio de una lista.
No medí formularios con cientos de campos, latencia al escribir, Firefox, Safari ni renderizado en el servidor.
Comentarios
Cargando comentarios...