@tinya-code/gas-admin-ui 0.2.0-alpha.15 → 0.2.0-alpha.18

package/src/lib/fields/display/display.spec.ts

@@ -1,242 +0,0 @@
-import { Component, input } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { beforeEach, describe, expect, it } from 'vitest';
-
-import type { FieldSchema, SelectField } from '../../core/models/schema.model';
-import { SUPPORTED_FIELD_TYPE_LIST } from '../descriptors';
-import { RenderHost } from '../../core/registry/render-host';
-import { displayLoader } from './display-defaults';
-
-/**
- * Paridad del modo `display` (R4.1 · R4.2).
- *
- * Cada caso es una fila de la tabla vieja `formatValue` de `detail-view`:
- * si un tipo pinta distinto de lo que pintaba antes de R4.2, este test se
- * pone rojo. Se monta por `RenderHost` y no por el componente suelto, para
- * que la prueba cubra también la rama de display del host (vacío, tabla y
- * degradación), no sólo el componente.
- */
-@Component({
-  selector: 'spec-display-host',
-  imports: [RenderHost],
-  template: `
-    <app-render-host
-      [type]="type()"
-      [config]="campo()"
-      mode="display"
-      [value]="valor()"
-      [chip]="chip()"
-    />
-  `,
-})
-class Host {
-  readonly type = input.required<string>();
-  readonly campo = input.required<FieldSchema>();
-  readonly valor = input<unknown>(null);
-  readonly chip = input(false);
-}
-
-describe('R4.1 — display por defecto según tipo', () => {
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({ imports: [Host] }).compileComponents();
-  });
-
-  /**
-   * Monta el host y espera el `load()` perezoso del display.
-   *
-   * `whenStable()` no cubre el `import()` dinámico (promesa ajena al rastreo
-   * de Angular), así que se espera acotadamente mientras quede `<app-skeleton>`;
-   * si el componente nunca monta, la espera se agota y falla la aserción.
-   */
-  async function pintar(campo: FieldSchema, valor: unknown, chip = false): Promise<HTMLElement> {
-    const fixture = TestBed.createComponent(Host);
-    fixture.componentRef.setInput('type', campo.type);
-    fixture.componentRef.setInput('campo', campo);
-    fixture.componentRef.setInput('valor', valor);
-    fixture.componentRef.setInput('chip', chip);
-    fixture.detectChanges();
-    await fixture.whenStable();
-    for (
-      let intento = 0;
-      intento < 100 && fixture.nativeElement.querySelector('app-skeleton');
-      intento++
-    ) {
-      fixture.detectChanges();
-      await new Promise((resolve) => setTimeout(resolve, 1));
-    }
-    fixture.detectChanges();
-    return fixture.nativeElement as HTMLElement;
-  }
-
-  const texto: FieldSchema = { key: 'nota', label: 'Nota', type: 'text' };
-  const fecha: FieldSchema = { key: 'fecha', label: 'Fecha', type: 'date' };
-  const numero: FieldSchema = { key: 'total', label: 'Total', type: 'number' };
-  const moneda: FieldSchema = { key: 'precio', label: 'Precio', type: 'currency' };
-  const booleano: FieldSchema = { key: 'activo', label: 'Activo', type: 'boolean' };
-  const estado: SelectField = {
-    key: 'status',
-    label: 'Estado',
-    type: 'select',
-    options: [
-      { value: 'PENDIENTE', label: 'Pendiente' },
-      { value: 'ENTREGADO', label: 'Entregado' },
-    ],
-  };
-  const imagen: FieldSchema = { key: 'foto', label: 'Foto', type: 'image' };
-  const historial: FieldSchema = {
-    key: 'history',
-    label: 'Historial',
-    type: 'list',
-    itemFields: [{ key: 'action', label: 'Acción', type: 'text' }],
-  };
-
-  it('los 21 tipos de la unión tienen display en la tabla', () => {
-    // Tripwire de la tabla: `Record<FieldType, …>` ya no compila si falta
-    // uno, pero el acceso en runtime pasa por `displayLoader()` con un
-    // `string` (un schema puede escribir cualquier cosa), y ahí sólo este
-    // test vigila que el string válido no caiga en `undefined`.
-    const sinDisplay = SUPPORTED_FIELD_TYPE_LIST.filter((type) => !displayLoader(type));
-    expect(sinDisplay).toEqual([]);
-  });
-
-  it('un type fuera de la unión degrada a control desconocido, no a pantalla roja', async () => {
-    const inventado = { key: 'x', label: 'X', type: 'wat' } as unknown as FieldSchema;
-    const nodo = await pintar(inventado, 'valor');
-    expect(nodo.querySelector('app-unknown-render'), 'debe pintarse la degradación').not.toBeNull();
-    expect(nodo.textContent).toContain('wat');
-  });
-
-  describe('vacío', () => {
-    // El criterio no cambia: `null`, `undefined` y `''` son vacío; `false`,
-    // `0` y `[]` no lo son.
-    for (const [nombre, valor] of [
-      ['null', null],
-      ['undefined', undefined],
-      ['cadena vacía', ''],
-    ] as const) {
-      it(`${nombre} pinta — y no monta componente`, async () => {
-        const nodo = await pintar(texto, valor);
-        expect(nodo.textContent).toContain('—');
-        expect(nodo.querySelector('app-field-display-text')).toBeNull();
-      });
-    }
-
-    it('false, 0 y [] sí se pintan', async () => {
-      expect((await pintar(booleano, false)).textContent).toContain('No');
-      expect((await pintar(numero, 0)).textContent).toContain('0');
-      expect((await pintar(historial, [])).textContent).toContain('historial');
-    });
-  });
-
-  describe('texto crudo', () => {
-    it('un string sale tal cual', async () => {
-      expect((await pintar(texto, 'ORD-42')).textContent).toContain('ORD-42');
-    });
-
-    it('un array sale unido por comas (String(raw), como antes)', async () => {
-      expect((await pintar(texto, ['a', 'b'])).textContent).toContain('a,b');
-    });
-
-    it('un objeto sale [object Object] (degradación heredada)', async () => {
-      expect((await pintar(texto, { a: 1 })).textContent).toContain('[object Object]');
-    });
-  });
-
-  it('date: es-PE, medium y UTC', async () => {
-    const nodo = await pintar(fecha, '2026-10-10');
-    // El mismo formato que usaba `formatValue`: sin UTC se correría un día.
-    expect(nodo.textContent).toContain('10 oct. 2026');
-  });
-
-  it('date no parseable se pinta crudo', async () => {
-    expect((await pintar(fecha, 'no-es-fecha')).textContent).toContain('no-es-fecha');
-  });
-
-  it('number y currency comparten formato es-PE', async () => {
-    expect((await pintar(numero, 1234567.5)).textContent).toContain('1,234,567.5');
-    expect((await pintar(moneda, 1234567.5)).textContent).toContain('1,234,567.5');
-  });
-
-  it('number no numérico se pinta crudo', async () => {
-    expect((await pintar(numero, 'muchos')).textContent).toContain('muchos');
-  });
-
-  describe('boolean', () => {
-    it('true → «Sí» en success', async () => {
-      const nodo = await pintar(booleano, true);
-      expect(nodo.textContent).toContain('Sí');
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-success');
-    });
-
-    it('false → «No» en neutral', async () => {
-      const nodo = await pintar(booleano, false);
-      expect(nodo.textContent).toContain('No');
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-neutral');
-    });
-  });
-
-  describe('select', () => {
-    it('el valor se traduce a la etiqueta de la opción', async () => {
-      const nodo = await pintar(estado, 'PENDIENTE');
-      expect(nodo.textContent).toContain('Pendiente');
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-accent/20');
-    });
-
-    it('un valor sin opción se pinta crudo con su clase de estado', async () => {
-      const nodo = await pintar(estado, 'DESCONOCIDO');
-      expect(nodo.textContent).toContain('DESCONOCIDO');
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-neutral');
-    });
-
-    it('ENTREGADO sigue siendo success (vocabulario heredado)', async () => {
-      const nodo = await pintar(estado, 'ENTREGADO');
-      expect(nodo.textContent).toContain('Entregado');
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-success');
-    });
-  });
-
-  it('image: miniatura enlazada con alt de la etiqueta', async () => {
-    const nodo = await pintar(imagen, 'https://x.test/a.png');
-    const img = nodo.querySelector('img');
-    expect(img?.getAttribute('src')).toBe('https://x.test/a.png');
-    expect(img?.getAttribute('alt')).toBe('Foto');
-    expect(nodo.querySelector('a')?.getAttribute('href')).toBe('https://x.test/a.png');
-  });
-
-  it('list: timeline con acción, fecha y detalle', async () => {
-    const nodo = await pintar(historial, [
-      { action: 'PEDIDO_CREADO', at: '2026-10-10T15:30:00Z', detail: 'Pedido registrado' },
-    ]);
-    expect(nodo.textContent).toContain('PEDIDO CREADO');
-    expect(nodo.textContent).toContain('Pedido registrado');
-    expect(nodo.textContent).toContain('10 oct. 2026');
-  });
-
-  it('list vacío sigue diciendo que no hay registros', async () => {
-    expect((await pintar(historial, [])).textContent).toContain(
-      'No hay registros en el historial.',
-    );
-  });
-
-  describe('chip de cabecera', () => {
-    it('un texto con chip sale como badge', async () => {
-      const nodo = await pintar(texto, 'ORD-42', true);
-      expect(nodo.querySelector('app-badge')?.textContent?.trim()).toBe('ORD-42');
-    });
-
-    it('una fecha con chip sale como badge con la fecha formateada', async () => {
-      const nodo = await pintar(fecha, '2026-10-10', true);
-      expect(nodo.querySelector('app-badge')?.textContent?.trim()).toBe('10 oct. 2026');
-    });
-
-    it('una lista con chip resume en «N elementos»', async () => {
-      const nodo = await pintar(historial, [{ action: 'X' }], true);
-      expect(nodo.querySelector('app-badge')?.textContent?.trim()).toBe('1 elementos');
-    });
-
-    it('un select con chip conserva la clase de estado', async () => {
-      const nodo = await pintar(estado, 'PENDIENTE', true);
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-accent/20');
-    });
-  });
-});

package/src/lib/fields/dropdown/dropdown.descriptor.ts

@@ -1,12 +0,0 @@
-import type { RenderDescriptor } from '../../core/registry/render-registry';
-
-/** Descriptor del campo `dropdown` (desplegable nativo siempre). */
-export const descriptor: RenderDescriptor = {
-  kind: 'field',
-  type: 'dropdown',
-  since: '1.0',
-  load: () => import('./dropdown').then((module) => module.FieldDropdown),
-  // Nace como cadena: el valor seleccionado es un string.
-  seed: 'string',
-  surfaces: ['form', 'display'],
-};

package/src/lib/fields/dropdown/dropdown.ts

@@ -1,45 +0,0 @@
-import { Component, computed, input } from '@angular/core';
-import { FormField } from '@angular/forms/signals';
-
-import type { DropdownField } from '../../core/models/schema.model';
-import { FieldAria } from '../field-aria';
-import { childTree, type RootTree } from '../field-node';
-
-/**
- * Desplegable nativo (`<select>`) que SIEMPRE se renderiza como lista
- * desplegable, independientemente de cuántas opciones tenga.
- *
- * A diferencia de `select` (que usa radio buttons para 2–4 opciones
- * estáticas por la guía de control §1), este tipo nunca muta a radios.
- * Úsalo cuando necesites un dropdown verdadero aunque tenga pocas opciones.
- */
-@Component({
-  selector: 'app-field-dropdown',
-  imports: [FieldAria, FormField],
-  template: `
-    <select
-      class="field-input"
-      [id]="state().name()"
-      [formField]="node()"
-    >
-      @if (!field().required) {
-        <option value="">{{ field().placeholder ?? '— Seleccionar —' }}</option>
-      }
-      @for (option of options(); track option.value) {
-        <option [value]="option.value" [disabled]="option.disabled ?? false">
-          {{ option.label }}
-        </option>
-      }
-    </select>
-  `,
-})
-export class FieldDropdown {
-  readonly field = input.required<DropdownField>();
-  readonly tree = input.required<RootTree>();
-
-  protected readonly node = computed(() => childTree<string>(this.tree(), this.field().key));
-  protected readonly state = computed(() => this.node()());
-
-  /** Opciones estáticas del schema (dropdown no soporta `source`). */
-  protected readonly options = computed(() => this.field().options);
-}

package/src/lib/fields/email/email.descriptor.ts

@@ -1,12 +0,0 @@
-import type { RenderDescriptor } from '../../core/registry/render-registry';
-
-/** Descriptor del campo `email` (R3.3). */
-export const descriptor: RenderDescriptor = {
-  kind: 'field',
-  type: 'email',
-  since: '1.0',
-  load: () => import('./email').then((module) => module.FieldEmail),
-  // Nace como cadena: los textos, fechas, urls, selects y relacionales.
-  seed: 'string',
-  surfaces: ['form', 'display'],
-};

package/src/lib/fields/email/email.ts

@@ -1,28 +0,0 @@
-import { Component, computed, input } from '@angular/core';
-import { FormField } from '@angular/forms/signals';
-
-import type { EmailField } from '../../core/models/schema.model';
-import { FieldAria } from '../field-aria';
-import { childTree, type RootTree } from '../field-node';
-
-/** Input de correo (base.md §5.1); la validación `email()` llega en Fase 10. */
-@Component({
-  selector: 'app-field-email',
-  imports: [FieldAria, FormField],
-  template: `
-    <input
-      type="email"
-      class="field-input"
-      [id]="state().name()"
-      [formField]="node()"
-      [placeholder]="field().placeholder ?? ''"
-    />
-  `,
-})
-export class FieldEmail {
-  readonly field = input.required<EmailField>();
-  readonly tree = input.required<RootTree>();
-
-  protected readonly node = computed(() => childTree<string>(this.tree(), this.field().key));
-  protected readonly state = computed(() => this.node()());
-}

package/src/lib/fields/field-aria.ts

@@ -1,60 +0,0 @@
-import { Directive, InjectionToken, computed, inject, type Signal } from '@angular/core';
-
-/**
- * Contexto de accesibilidad que `app-field-host` expone a los controles.
- *
- * El host conoce la ayuda y el error (ambos viven en SU plantilla), pero el
- * `<input>` real vive dentro de un componente hijo distinto por cada tipo de
- * campo. En lugar de pasar dos inputs por cada uno de los 14 controles, el
- * host provee este contexto y cada control importa `FieldAria`, que lo lee
- * por DI y lo vuelca en el elemento.
- *
- * Selector por `[id]`: casa sólo con el elemento que ya recibe el `for` de la
- * etiqueta, así el mismo id es ancla de label y de `aria-describedby`. Los
- * controles fuera de un `app-field-host` inyectan `null` y no emiten nada.
- */
-export interface FieldAriaContext {
-  /** `id` del texto de ayuda y/o del error, separados por espacio. */
-  readonly describedBy: Signal<string | null>;
-  /** `true` cuando el campo muestra error visible (mismo criterio que el mensaje). */
-  readonly invalid: Signal<boolean>;
-  /**
-   * Requerido por schema. Necesario porque la marca visual `*` desaparece en
-   * los recursos donde mandan los `(opcional)` (§2): sin este atributo el
-   * requerimiento quedaría sólo en pantalla.
-   */
-  readonly required: Signal<boolean>;
-}
-
-export const FIELD_ARIA = new InjectionToken<FieldAriaContext>('FIELD_ARIA');
-
-/**
- * Vincula `aria-invalid` y `aria-describedby` a un control de formulario.
- *
- * `aria-invalid` se emite SIEMPRE (`"true"`/`"false"`, nunca ausente) para
- * que el atributo sea inspeccionable en cualquier estado; `aria-describedby`
- * se omite cuando no hay ni ayuda ni error, que es el caso por defecto.
- * `aria-required` sigue la misma regla que `aria-invalid`.
- *
- * Convención con `role="alert"` en el mensaje de error: el `alert` anuncia el
- * error en el momento en que aparece (fallo de submit), mientras que
- * `aria-describedby` lo lee al enfocar el campo. Son momentos distintos; no
- * compiten.
- */
-@Directive({
-  selector: 'input[id], select[id], textarea[id], output[id]',
-  host: {
-    '[attr.aria-invalid]': 'ariaInvalid()',
-    '[attr.aria-required]': 'ariaRequired()',
-    '[attr.aria-describedby]': 'ariaDescribedBy()',
-  },
-})
-export class FieldAria {
-  private readonly ctx = inject(FIELD_ARIA, { optional: true });
-
-  protected readonly ariaInvalid = computed(() => (this.ctx ? String(this.ctx.invalid()) : null));
-
-  protected readonly ariaRequired = computed(() => (this.ctx ? String(this.ctx.required()) : null));
-
-  protected readonly ariaDescribedBy = computed(() => this.ctx?.describedBy() ?? null);
-}

package/src/lib/fields/field-host/field-host.spec.ts

@@ -1,118 +0,0 @@
-import { Component, EnvironmentInjector, input, signal } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { By } from '@angular/platform-browser';
-import { form } from '@angular/forms/signals';
-import { of } from 'rxjs';
-import { describe, expect, it } from 'vitest';
-
-import type { FieldSchema, ResourceSchema } from '../../core/models/schema.model';
-import type { ApiService } from '../../core/services/api.service';
-import { seedModel } from '../../pages/form-view/form-model';
-import { buildFormSchema } from '../../pages/form-view/form-schema';
-import { childTree, type RootTree } from '../field-node';
-import { UnknownRender } from '../unknown-render/unknown-render';
-import { FieldHost } from './field-host';
-
-/**
- * R1.10 — degradación controlada de un tipo de campo sin renderizador.
- *
- * El `@switch` del host NO tiene `@default`, así que un `type` fuera del
- * catálogo no revienta el template: no dibuja nada. Eso cumple «nunca
- * pantalla rota», pero deja un hueco mudo donde el operador no distingue
- * «me falta un campo» de «lo escribí mal». El aviso existe sólo en dev
- * (`isDevMode`); en producción se omite y queda un `console.warn`.
- *
- * **Por qué el cast:** `FieldSchema.type` es unión, así que `tsc` no deja
- * declarar un tipo desconocido — eso lo garantiza el tripwire de R1.7. Este
- * test simula el estado en runtime que el compilador impide llegar a
- * producción (schema versionado a mano, instancia con un registro viejo,
- * `record` de un repo de schemas externo), que es exactamente lo que la
- * degradación tiene que tolerar.
- */
-@Component({
-  template: ` <app-field-host [field]="field()" [tree]="tree()" /> `,
-  imports: [FieldHost],
-})
-class Host {
-  readonly field = input.required<FieldSchema>();
-  readonly tree = input.required<RootTree>();
-}
-
-describe('FieldHost — tipo de campo sin renderizador', () => {
-  const API = { list: () => of([]) } as unknown as ApiService;
-
-  /** Árbol real, con las mismas reglas que usa `FormView` (para `hidden`). */
-  function treeFor(schema: ResourceSchema): RootTree {
-    const model = signal(seedModel(schema));
-    return form(model, buildFormSchema(schema, API), {
-      injector: TestBed.inject(EnvironmentInjector),
-    }) as unknown as RootTree;
-  }
-
-  function schemaWith(field: Partial<FieldSchema>): ResourceSchema {
-    return {
-      id: '__unknown__',
-      label: 'Prueba',
-      labelPlural: 'Pruebas',
-      kind: 'collection',
-      endpoint: { list: '/admin/__unknown__' },
-      keyField: 'marca',
-      titleField: 'marca',
-      listColumns: [],
-      fields: [{ key: 'marca', type: 'text', label: 'Marca' }, { ...field } as FieldSchema],
-    } as ResourceSchema;
-  }
-
-  async function render(field: Partial<FieldSchema>, schema?: ResourceSchema) {
-    await TestBed.configureTestingModule({ imports: [Host] }).compileComponents();
-    const s = schema ?? schemaWith(field);
-    const fixture = TestBed.createComponent(Host);
-    fixture.componentRef.setInput('field', field as FieldSchema);
-    fixture.componentRef.setInput('tree', treeFor(s));
-    fixture.detectChanges();
-    await fixture.whenStable();
-    fixture.detectChanges();
-    return fixture;
-  }
-
-  const desconocido = { key: 'gorro', type: 'sombrero', label: 'Talla' } as unknown as FieldSchema;
-
-  it('un tipo fuera del catálogo dibuja el aviso en vez de dejar un hueco', async () => {
-    const fixture = await render(desconocido, schemaWith(desconocido));
-
-    const aviso = fixture.debugElement.query(By.directive(UnknownRender));
-    expect(aviso, 'debería renderizar app-unknown-render').not.toBeNull();
-    expect(aviso.nativeElement.textContent).toContain('sombrero');
-    expect(aviso.nativeElement.textContent).toContain('Talla');
-
-    // Y no intenta dibujar un control que no sabe armar.
-    expect(fixture.nativeElement.querySelector('input, textarea, select')).toBeNull();
-  });
-
-  it('un tipo del catálogo NO muestra el aviso', async () => {
-    const fixture = await render({ key: 'gorro', type: 'text', label: 'Gorro' });
-
-    expect(fixture.debugElement.query(By.directive(UnknownRender))).toBeNull();
-    expect(fixture.nativeElement.querySelector('input')).not.toBeNull();
-  });
-
-  it('un campo oculto (tipo soportado) cae en el mismo @else pero NO avisa', async () => {
-    // La rama `@else` del host cubre DOS motivos: «fuera de catálogo» y
-    // «oculto por hiddenOn». Sin el chequeo `unsupported()`, un campo
-    // legítimamente oculto expondría un aviso ruidoso.
-    //
-    // (La recíproca —un tipo desconocido Y oculto— no es alcanzable: al
-    // siembrarse `undefined` no tiene nodo, así que tampoco tiene regla de
-    // `hidden`; lo cubre el docblock de `unsupported`.)
-    const oculto = {
-      key: 'gorro',
-      type: 'text',
-      label: 'Talla',
-      hiddenOn: 'always',
-    } as FieldSchema;
-
-    const fixture = await render(oculto, schemaWith(oculto));
-    expect(fixture.debugElement.query(By.directive(UnknownRender))).toBeNull();
-    expect(fixture.nativeElement.querySelector('input')).toBeNull();
-  });
-});

package/src/lib/fields/field-host/field-host.ts

@@ -1,47 +0,0 @@
-import { Component, computed, input } from '@angular/core';
-
-import type { FieldSchema } from '../../core/models/schema.model';
-import { RenderHost, type RenderContext } from '../../core/registry/render-host';
-import type { RootTree } from '../field-node';
-
-/**
- * Entrada estable de los formularios (base.md §5).
- *
- * **R3.5 · ya no despacha.** Este host redujo sus 493 líneas —el `@switch`
- * de 20 ramas, los 21 imports a mano y el envoltorio de label/errores— a un
- * adaptador que traduce su API histórica (`field` + `tree` + `pathPrefix` …)
- * al `RenderContext` que espera `<app-render-host>`, el motor único de
- * render (F1 · `refactormotor.md`).
- *
- * El rótulo, las marcas required/opcional, el error, la ayuda,
- * `FIELD_ARIA` y la **recursión de `group`/`list`** (los `ng-template` con
- * `ngTemplateOutlet` y `ListChildContext`) viven ahora en `RenderHost`, que
- * se auto-importa para instanciar sus propios hijos.
- *
- * Rutas del backend: `pathPrefix` encadena el prefijo del contenedor
- * (`address.`, `faq[2].`) y `serverErrors` lleva el mapa completo; el error
- * propio de este campo se resuelve como `serverErrors[prefix + key]`.
- */
-@Component({
-  selector: 'app-field-host',
-  imports: [RenderHost],
-  template: `
-    <app-render-host kind="field" [type]="field().type" [config]="field()" [ctx]="ctx()" />
-  `,
-})
-export class FieldHost {
-  readonly field = input.required<FieldSchema>();
-  readonly tree = input.required<RootTree>();
-  readonly exists = input(false);
-  readonly serverErrors = input<Record<string, string>>({});
-  readonly pathPrefix = input('');
-  readonly resource = input('');
-
-  protected readonly ctx = computed<RenderContext>(() => ({
-    tree: this.tree(),
-    serverErrors: this.serverErrors(),
-    pathPrefix: this.pathPrefix(),
-    exists: this.exists(),
-    resource: this.resource(),
-  }));
-}

package/src/lib/fields/field-node.ts

@@ -1,88 +0,0 @@
-/**
- * Acceso dinámico a los subárboles de un formulario cuyo modelo es
- * `Record<string, unknown>` (decisión Fase 10: el tipado del modelo como
- * Record permite indexar con cualquier clave, pero el acceso se centraliza
- * aquí porque devuelve `undefined` en el tipo).
- *
- * Fase 11: los contenedores (`group`, `list`) se resuelven igual, más los
- * índices de las listas (`itemTree`).
- */
-
-import type { FieldTree } from '@angular/forms/signals';
-
-import type { FieldSchema } from '../core/models/schema.model';
-
-/** Árbol de un formulario con modelo dinámico. */
-export type RootTree = FieldTree<Record<string, unknown>>;
-
-/**
- * Contexto que el `ng-template` del `list` recibe por `ngTemplateOutlet`
- * para renderizar los campos de un ítem. El template vive en el despachador
- * (`field-host`) porque es el único que puede instanciar `app-field-host`;
- * el list lo instancia una vez por ítem con este contexto.
- */
-export interface ListChildContext {
-  fields: readonly FieldSchema[];
-  tree: RootTree;
-  /** Prefijo de ruta de los errores del backend para este nivel (`faq[2].`). */
-  prefix: string;
-  errors: Record<string, string>;
-  exists: boolean;
-  /** `itemDisplay: 'row'` → los campos van en flujo compacto, no en grilla. */
-  row: boolean;
-  /** Clase `sm:col-span-*` de un campo (literal: Tailwind v4 es JIT). */
-  colSpan: (width?: number) => string;
-}
-
-/** Subárbol del hijo directo bajo `key`. Lanza un error claro si el modelo no
- * contiene la clave (los modelos se siembran con los `default` del schema
- * antes de llamar a `form()`).
- */
-export function childTree<T>(parent: RootTree, key: string): FieldTree<T> {
-  const child = (parent as unknown as Record<string, FieldTree<T> | undefined>)[key];
-  if (child === undefined) {
-    throw new Error(`El formulario no contiene el campo "${key}".`);
-  }
-  return child;
-}
-
-/** Subárbol de un campo `list`/`group` cuyo valor es un objeto. */
-export function groupTree(parent: RootTree, key: string): RootTree {
-  return childTree<Record<string, unknown>>(parent, key);
-}
-
-/** Subárbol de un campo `list` (los ítems se acceden por índice). */
-export function listTree<T>(parent: RootTree, key: string): FieldTree<T[]> {
-  return childTree<T[]>(parent, key);
-}
-
-/**
- * Ítem de una lista como árbol navegable.
- *
- * **Los nodos de ítem se atan a la identidad del elemento**, no al índice:
- * tras un cambio del arreglo el nodo viejo queda huérfano y leerlo lanza
- * `NG01904 «Orphan field»`. Por eso este helper se llama SIEMPRE fresco, en
- * cada render/computed — nunca se cachea un nodo entre mutaciones.
- *
- * El `as unknown` es porque `FieldTree<Item, number>` no es assignable a
- * `RootTree` (le falta el index signature de `string`), pero se navega igual.
- */
-export function itemTree<T>(items: FieldTree<T[]>, index: number): RootTree {
-  const item = items[index];
-  if (item === undefined) {
-    throw new Error(`La lista no contiene el índice ${index}.`);
-  }
-  return item as unknown as RootTree;
-}
-
-/**
- * Ítem escalar de un `string-list` como nodo (`FieldTree<string>`), listo
- * para `[formField]`. Mismo criterio de frescura que `itemTree`.
- */
-export function stringItemTree(items: FieldTree<string[]>, index: number): FieldTree<string> {
-  const item = items[index] as FieldTree<string> | undefined;
-  if (item === undefined) {
-    throw new Error(`La lista no contiene el índice ${index}.`);
-  }
-  return item;
-}

package/src/lib/fields/file/file.descriptor.ts

@@ -1,14 +0,0 @@
-import type { RenderDescriptor } from '../../core/registry/render-registry';
-
-/** Descriptor del campo `file` (R3.3 · R9.5.3). */
-export const descriptor: RenderDescriptor = {
-  kind: 'field',
-  type: 'file',
-  since: '9.5',
-  load: () => import('./file').then((module) => module.FieldFile),
-  // Nace como cadena: la URL pública es el valor, igual que en `image`.
-  seed: 'string',
-  surfaces: ['form', 'display'],
-  // Como `image` (D27): control propio cuya sincronización con Signal Forms
-  // vive en ɵɵcontrol, así que el host lo declara a mano con `[formField]`.
-};