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

package/src/lib/actions/descriptors.ts

@@ -1,154 +0,0 @@
-import { firstValueFrom } from 'rxjs';
-import { LucideShare2 } from '@lucide/angular';
-
-import type { ActionDescriptor } from './action-registry';
-import type {
-  CopyShareAction,
-  NavigateAction,
-  ResourceAction,
-  TriggerAction,
-} from '../core/models/schema.model';
-import { buildShareMessage, writeClipboard } from '../core/utils/clipboard';
-import { interpolateTemplate } from '../core/utils/template-interpolator';
-
-/**
- * Descriptores de las tres acciones que hoy declara el modelo
- * (R3.10 · `doc/plan-refactor-motor.md` §3.2).
- *
- * Éste es el fichero que **cierra la triplicación de `copy-share`**: la
- * resolución de enlace y de mensaje vivía en `list-view.runAction`,
- * `detail-view.resolveUrl/resolveShareText` y
- * `post-create-modal.resolvedShareUrl/resolvedShareText`. Aquí se resuelve
- * una sola vez (`resolveShare`) y las vistas consumen ese resultado en R3.11.
- *
- * Se registra al importar, desde `action-registry.ts`, con el mismo criterio
- * que el registro de render: sin esperar a DI, porque el registro es la única
- * fuente de verdad en runtime.
- */
-
-/** Enlace y mensaje ya interpolados, listos para copiar o compartir. */
-export interface ResolvedShare {
-  url: string;
-  shareText: string;
-}
-
-/**
- * `true` cuando la acción es de las que las vistas presentan como botón de
- * compartir (`detail-view`, `post-create-modal`).
- *
- * Vive acá y no en la vista porque es **el único sitio donde se puede nombrar
- * `'copy-share'`**: fuera de `descriptors.ts` ninguna vista decide por tipo
- * (criterio de R3.11).
- */
-export function isShareAction(action: ResourceAction): action is CopyShareAction {
-  return action.type === 'copy-share';
-}
-
-/**
- * `true` cuando la acción es un `trigger` (acción de dominio del back).
- *
- * Mismo criterio que `isShareAction`: el único sitio que nombra el tipo,
- * para que las vistas no decidan por string literal (R3.11). `detail-view`
- * lo usa en R8.8 para renderizar «Regenerar PIN» junto a los botones de
- * compartir.
- */
-export function isTriggerAction(action: ResourceAction): action is TriggerAction {
-  return action.type === 'trigger';
-}
-
-/**
- * Resuelve `urlTemplate` y el mensaje de compartir contra `vars`
- * (config global + registro).
- *
- * **Única implementación** de esta lógica en el admin. El fallback a
- * `share_message_template` (la plantilla que declara el singleton de
- * configuración) lo aplican los tres puntos por igual: hasta ahora la fila
- * del listado no lo honraba y se quedaba sin saludo.
- */
-export function resolveShare(
-  action: CopyShareAction,
-  vars: Record<string, unknown>,
-): ResolvedShare {
-  const template =
-    action.shareTextTemplate || (vars['share_message_template'] as string | undefined);
-  return {
-    url: interpolateTemplate(action.urlTemplate, vars),
-    shareText: template ? interpolateTemplate(template, vars) : '',
-  };
-}
-
-/** `copy-share` — copia (o comparte) el mensaje completo del enlace público. */
-const copyShare: ActionDescriptor = {
-  type: 'copy-share',
-  surfaces: ['row', 'detail', 'post-create'],
-  // Icono de la fila del listado: la vista sólo decide entre «icono» y
-  // «rótulo», nunca por tipo. Se pasa la CLASE, no el nombre: sin
-  // `provideLucideIcons` no hay riesgo de `Unable to resolve icon`.
-  icon: LucideShare2,
-  run: async (ctx, action) => {
-    const { url, shareText } = resolveShare(action as CopyShareAction, ctx.vars);
-    const message = buildShareMessage(url, shareText);
-    const copied = await writeClipboard(message);
-    if (copied) {
-      ctx.toast.success('Mensaje copiado al portapapeles.');
-    } else {
-      ctx.toast.info(`Copiar manualmente: ${message}`);
-    }
-    return { ok: true };
-  },
-};
-
-/**
- * `navigate` — abre la plantilla resuelta: URL absoluta en otra pestaña,
- * ruta interna en el router. `NavigateAction.type` es opcional, así que el
- * servicio llega acá también con una acción que no declara `type`.
- */
-const navigate: ActionDescriptor = {
-  type: 'navigate',
-  surfaces: ['row', 'detail'],
-  run: async (ctx, action) => {
-    const url = interpolateTemplate((action as NavigateAction).urlTemplate, ctx.vars);
-    if (/^https?:\/\//.test(url)) {
-      window.open(url, '_blank', 'noopener');
-    } else {
-      await ctx.router.navigateByUrl(url);
-    }
-    return { ok: true };
-  },
-};
-
-/**
- * `trigger` — dispara una **acción de dominio declarada en el back** (B3).
- *
- * **R3.12:** el destino ya no lo declara el schema (`endpoint` y `method`
- * murieron en este cambio). Se deriva de `resource` + clave del registro +
- * `name` (o `id`), que es exactamente la ruta que el back publica solo en
- * R5.4: `POST /admin/<recurso>/:id/actions/<name>`.
- *
- * ⚠️ **O2:** la ruta lógica viaja en el `path` del envelope, no en la URL —
- * el HTTP sigue siendo el `POST API_URL` de siempre.
- *
- * Siempre pide confirmación: es la única acción de las tres que puede dejar
- * una cola de trabajo hecha.
- */
-const trigger: ActionDescriptor = {
-  type: 'trigger',
-  surfaces: ['row', 'detail'],
-  confirm: true,
-  run: async (ctx, action) => {
-    const declared = action as TriggerAction;
-    const rawKey = ctx.record?.[ctx.keyField];
-    if (rawKey === null || rawKey === undefined || rawKey === '') {
-      throw new Error(
-        `La acción «${declared.label}» necesita la clave ${ctx.keyField} del registro.`,
-      );
-    }
-    const name = declared.name ?? declared.id;
-    const route = `/admin/${ctx.resource}/${String(rawKey)}/actions/${name}`;
-    await firstValueFrom(ctx.api.request('POST', route));
-    return { ok: true, reload: true };
-  },
-};
-
-/** Catálogo — una línea por acción, en el orden en que se registran. */
-export const actionDescriptors: readonly ActionDescriptor[] = [copyShare, navigate, trigger];

package/src/lib/columns/column-cell.ts

@@ -1,33 +0,0 @@
-import type { FieldSchema, ListColumn } from '../core/models/schema.model';
-
-type Row = Record<string, unknown>;
-
-/**
- * Contexto de una celda de listado (R4.3 · `kind: 'column-format'`).
- *
- * Es lo que antes cada `@case` de `list-view` pedía a la vista como
- * `row`/`column` y lo que el descriptor cuelga de `extras.data`: el
- * componente de formato no conoce a la vista, sólo a su celda.
- *
- * `fields`, `canUpdate`, `saving`, `currency` y `toggle` viajan acá porque
- * son decisiones de la vista (permisos, moneda del schema, escritura de la
- * fila); un formato nuevo no necesita tocar `list-view` para leerlas.
- */
-export interface ColumnCell {
-  /** Fila completa. */
-  row: Row;
-  /** Columna que se pinta (`key`, `label`, `format`). */
-  column: ListColumn;
-  /** Campos del recurso: de acá salen `trueLabel`/`falseLabel`. */
-  fields: FieldSchema[];
-  /** `titleField` de la fila, para el `aria-label` del interruptor. */
-  title: string;
-  /** ¿La fila admite escritura? (`ListView.canUpdate`) */
-  canUpdate: boolean;
-  /** ¿La fila está guardando? (`ListView.savingKey === keyOf(row)`) */
-  saving: boolean;
-  /** Moneda del schema, para el formato `currency`. */
-  currency: string;
-  /** Escribe el valor en la fila. Sólo lo usa el interruptor `active`. */
-  toggle?: (checked: boolean) => void;
-}

package/src/lib/columns/column-defaults.spec.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { SUPPORTED_FIELD_TYPE_LIST } from '../fields/descriptors';
-import type { FieldSchema, ListColumn } from '../core/models/schema.model';
-import { FORMATO_POR_DEFECTO, formatoDeColumna, formatoPorTipo } from './column-defaults';
-
-/**
- * R4.4 — «declarada, no implícita»: la tabla de formato por defecto.
- *
- * Dos promesas: que la tabla cubra **todos** los tipos del catálogo, y que
- * una columna sin `format` pinta lo que la tabla dice — no un `?? 'text'`
- * implícito que dependía de la memoria de quien escribía el schema.
- */
-describe('R4.4 — formato por defecto según field.type', () => {
-  const columna = (parcial: Partial<ListColumn> & Pick<ListColumn, 'key'>): ListColumn => ({
-    label: parcial.key,
-    ...parcial,
-  });
-  const campo = (key: string, type: FieldSchema['type']): FieldSchema =>
-    ({ key, label: key, type }) as FieldSchema;
-
-  it('cubre exactamente el catálogo de tipos de campo', () => {
-    // El `Record<FieldType, …>` ya lo exige en compilación; el test además
-    // fija que ningún tipo se quede sin fila ni aparezca una fantasma.
-    expect(Object.keys(FORMATO_POR_DEFECTO).sort()).toEqual([...SUPPORTED_FIELD_TYPE_LIST].sort());
-    expect(SUPPORTED_FIELD_TYPE_LIST.length).toBe(24);
-  });
-
-  it('repasa la paridad tipo a tipo con el display del detalle', () => {
-    const esperado: Record<string, string> = {
-      text: 'text',
-      textarea: 'text',
-      slug: 'text',
-      url: 'text',
-      email: 'text',
-      phone: 'text',
-      'readonly-text': 'text',
-      relation: 'text',
-      group: 'text',
-      'key-value': 'text',
-      'string-list': 'text',
-      multiselect: 'text',
-      time: 'text',
-      list: 'text',
-      date: 'date',
-      number: 'number',
-      currency: 'currency',
-      boolean: 'boolean',
-      select: 'badge',
-      image: 'thumbnail',
-      file: 'text',
-      color: 'text',
-      'rich-select': 'badge',
-      dropdown: 'badge',
-    };
-    expect(Object.keys(FORMATO_POR_DEFECTO).sort()).toEqual(Object.keys(esperado).sort());
-    for (const [tipo, formato] of Object.entries(esperado)) {
-      expect(formatoPorTipo(tipo), `tipo ${tipo}`).toBe(formato);
-    }
-  });
-
-  it('la declaración del schema manda sobre la tabla', () => {
-    expect(
-      formatoDeColumna(columna({ key: 'status', format: 'text' }), [campo('status', 'select')]),
-    ).toBe('text');
-    expect(
-      formatoDeColumna(columna({ key: 'price', format: 'badge' }), [campo('price', 'currency')]),
-    ).toBe('badge');
-  });
-
-  it('sin formato declarado usa el tipo del campo', () => {
-    const campos = [
-      campo('status', 'select'),
-      campo('pickup_date', 'date'),
-      campo('active', 'boolean'),
-      campo('photo', 'image'),
-      campo('price', 'currency'),
-      campo('name', 'slug'),
-    ];
-    expect(formatoDeColumna(columna({ key: 'status' }), campos)).toBe('badge');
-    expect(formatoDeColumna(columna({ key: 'pickup_date' }), campos)).toBe('date');
-    expect(formatoDeColumna(columna({ key: 'active' }), campos)).toBe('boolean');
-    expect(formatoDeColumna(columna({ key: 'photo' }), campos)).toBe('thumbnail');
-    expect(formatoDeColumna(columna({ key: 'price' }), campos)).toBe('currency');
-    expect(formatoDeColumna(columna({ key: 'name' }), campos)).toBe('text');
-  });
-
-  it('una columna sin campo asociado o con tipo mal escrito degrada a text', () => {
-    // El `@default` del `@switch` que R4.3 reemplazó: la degradación es la
-    // misma y nunca lanza.
-    expect(formatoDeColumna(columna({ key: 'inventada' }), [campo('otra', 'text')])).toBe('text');
-    expect(formatoPorTipo('holograma')).toBeUndefined();
-    expect(
-      formatoDeColumna(columna({ key: 'raro' }), [
-        campo('raro', 'holograma' as FieldSchema['type']),
-      ]),
-    ).toBe('text');
-  });
-});

package/src/lib/columns/column-defaults.ts

@@ -1,84 +0,0 @@
-import type {
-  FieldSchema,
-  FieldType,
-  ListColumn,
-  ListColumnFormat,
-} from '../core/models/schema.model';
-
-/**
- * **Tabla de formato de columna por defecto según `field.type`** (R4.4 del
- * plan): «declarada, no implícita» — `column.format` sólo sirve para
- * sobreescribirla.
- *
- * Es la hermana de `fields/display/display-defaults.ts` (R4.1): un solo
- * sitio decide qué pinta una columna cuando el schema no dice nada, en vez
- * de un `?? 'text'` repartido por la vista. El vocabulario se alinea con el
- * display del detalle — `select` es chip, `date` es fecha, `image` es
- * miniatura — con las dos concesiones que sólo el listado puede hacer:
- * `boolean` baja al interruptor (R4.3) en vez de al chip, y `list`, que en
- * la ficha es timeline, acá sigue siendo texto porque el registro de
- * formatos no tiene timeline (D41).
- *
- * `Record<FieldType, …>` es el **tripwire de exhaustividad en compilación**:
- * un tipo nuevo obliga a elegir su formato de lista antes de que el build
- * pase, y un tipo retirado obliga a limpiar la entrada.
- */
-export const FORMATO_POR_DEFECTO: Record<FieldType, ListColumnFormat> = {
-  text: 'text',
-  textarea: 'text',
-  slug: 'text',
-  url: 'text',
-  email: 'text',
-  phone: 'text',
-  'readonly-text': 'text',
-  relation: 'text',
-  group: 'text',
-  'key-value': 'text',
-  'string-list': 'text',
-  multiselect: 'text',
-  time: 'text',
-  list: 'text',
-  date: 'date',
-  number: 'number',
-  currency: 'currency',
-  boolean: 'boolean',
-  select: 'badge',
-  image: 'thumbnail',
-  // Un archivo no tiene miniatura: en la lista va como URL en crudo (R9.5.3).
-  file: 'text',
-  // Un color se pinta como texto (el hex #RRGGBB) en el listado.
-  color: 'text',
-  // Un rich-select se pinta como badge con el label de la opción.
-  'rich-select': 'badge',
-  // Un dropdown se pinta como badge con el label de la opción.
-  dropdown: 'badge',
-};
-
-/**
- * Formato por defecto para un `type`, o `undefined` si el schema lo escribió
- * mal (tipo fuera de la unión). La degradación — igual que `displayLoader()` —
- * es `text`, que era el `@default` del `@switch` que R4.3 reemplazó.
- */
-export function formatoPorTipo(type: string): ListColumnFormat | undefined {
-  return Object.prototype.hasOwnProperty.call(FORMATO_POR_DEFECTO, type)
-    ? FORMATO_POR_DEFECTO[type as FieldType]
-    : undefined;
-}
-
-/**
- * Formato final de una columna: la declaración del schema si existe, si no,
- * la tabla de arriba según el `type` del campo con esa `key`, y si la columna
- * ni siquiera aparece en `fields` (columna derivada o key inventada), `text`.
- *
- * Es la única puerta por la que `list-view` decide qué pinta una celda.
- */
-export function formatoDeColumna(
-  column: ListColumn,
-  fields: readonly FieldSchema[],
-): ListColumnFormat {
-  if (column.format) {
-    return column.format;
-  }
-  const field = fields.find((candidate) => candidate.key === column.key);
-  return (field ? formatoPorTipo(field.type) : undefined) ?? 'text';
-}

package/src/lib/columns/column-format.spec.ts

@@ -1,274 +0,0 @@
-import { Component, input } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type { ListColumn } from '../core/models/schema.model';
-import { RenderHost } from '../core/registry/render-host';
-import { COLUMN_FORMAT_TYPES } from './descriptors';
-import type { ColumnCell } from './column-cell';
-
-/**
- * Los 7 formatos de columna (R4.3 · `kind: 'column-format'`).
- *
- * Cada caso es un `@case` del `@switch` que vivía en `list-view`: si el
- * formato pinta distinto de lo que pintaba allí, este test se pone rojo. Se
- * monta por `RenderHost` y no por el componente suelto para cubrir también
- * la resolución del registro (descriptor, `inputs`, degradación).
- */
-@Component({
-  selector: 'spec-column-host',
-  imports: [RenderHost],
-  template: `
-    <app-render-host kind="column-format" [type]="formato()" [config]="column()" [data]="cell()" />
-  `,
-})
-class Host {
-  readonly formato = input.required<string>();
-  readonly column = input.required<ListColumn>();
-  readonly cell = input.required<ColumnCell>();
-}
-
-describe('R4.3 — formatos de columna registrados', () => {
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({ imports: [Host] }).compileComponents();
-  });
-
-  /**
-   * Monta el host y espera el `load()` perezoso del formato.
-   *
-   * `whenStable()` no cubre el `import()` dinámico por sí solo, así que se
-   * espera acotadamente mientras quede `<app-skeleton>`; si el formato nunca
-   * monta, la espera se agota y falla la aserción del test.
-   */
-  async function pintar(column: ListColumn, cell: Partial<ColumnCell> = {}): Promise<HTMLElement> {
-    const fixture = TestBed.createComponent(Host);
-    fixture.componentRef.setInput('formato', column.format ?? 'text');
-    fixture.componentRef.setInput('column', column);
-    fixture.componentRef.setInput('cell', celda({ column, ...cell }));
-    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;
-  }
-
-  /** Texto de la celda con los espacios duros de `Intl` normalizados. */
-  function texto(nodo: HTMLElement): string {
-    return (nodo.textContent ?? '').replace(/\u00a0/g, ' ');
-  }
-
-  /** Celda mínima; cada caso sobreescribe lo que necesita. */
-  function celda(parcial: { column: ListColumn } & Partial<ColumnCell>): ColumnCell {
-    return {
-      row: {},
-      fields: [],
-      title: 'Una fila',
-      canUpdate: false,
-      saving: false,
-      currency: 'PEN',
-      ...parcial,
-    };
-  }
-
-  it('los 7 formatos de la unión están registrados', () => {
-    // `ListColumnFormat` vive en tipos y el manifiesto en runtime: sólo un
-    // test reconcilia los dos (mismo tripwire que campos y widgets).
-    expect(COLUMN_FORMAT_TYPES.length).toBe(7);
-  });
-
-  describe('text', () => {
-    const col: ListColumn = { key: 'nombre', label: 'Nombre', format: 'text' };
-
-    it('pinta el valor crudo', async () => {
-      const nodo = await pintar(col, { row: { nombre: 'ORD-42' } });
-      expect(nodo.textContent).toContain('ORD-42');
-    });
-
-    it('null y undefined salen vacíos', async () => {
-      expect((await pintar(col, { row: { nombre: null } })).textContent?.trim()).toBe('');
-      expect((await pintar(col, { row: {} })).textContent?.trim()).toBe('');
-    });
-
-    it('un objeto sale [object Object] (degradación heredada)', async () => {
-      const nodo = await pintar(col, { row: { nombre: { a: 1 } } });
-      expect(nodo.textContent).toContain('[object Object]');
-    });
-  });
-
-  describe('number', () => {
-    const col: ListColumn = { key: 'stock', label: 'Stock', format: 'number' };
-
-    it('agrupa con separador es-PE', async () => {
-      const nodo = await pintar(col, { row: { stock: 1234567.5 } });
-      expect(nodo.textContent).toContain('1,234,567.5');
-    });
-
-    it('no numérico sale crudo y null sigue saliendo «0»', async () => {
-      expect((await pintar(col, { row: { stock: 'varios' } })).textContent).toContain('varios');
-      // Quirk heredado de `formatNumber`: `Number(null)` es 0 y por eso la
-      // lista ya mostraba «0» en vez de vacío. Se conserva — cambiarlo es
-      // otra decisión, no este registro.
-      expect((await pintar(col, { row: { stock: null } })).textContent?.trim()).toBe('0');
-    });
-  });
-
-  describe('currency', () => {
-    const col: ListColumn = { key: 'price', label: 'Precio', format: 'currency' };
-
-    it('usa la moneda que entrega la vista', async () => {
-      const nodo = await pintar(col, { row: { price: 1234.5 } });
-      // `Intl` separa el símbolo con espacio duro (U+00A0): se normaliza para
-      // que el aserto no dependa de ese byte.
-      expect(texto(nodo)).toContain('S/ 1,234.50');
-    });
-
-    it('cambia de moneda con la celda', async () => {
-      const nodo = await pintar(col, { row: { price: 1234.5 }, currency: 'USD' });
-      expect(texto(nodo)).toContain('USD 1,234.50');
-    });
-  });
-
-  describe('date', () => {
-    const col: ListColumn = { key: 'fecha', label: 'Fecha', format: 'date' };
-
-    it('formato corto es-PE en UTC', async () => {
-      const nodo = await pintar(col, { row: { fecha: '2026-12-25' } });
-      expect(nodo.textContent).toContain('25/12/2026');
-    });
-
-    it('no parseable sale crudo', async () => {
-      expect((await pintar(col, { row: { fecha: 'ayer' } })).textContent).toContain('ayer');
-    });
-  });
-
-  describe('badge', () => {
-    const col: ListColumn = { key: 'status', label: 'Estado', format: 'badge' };
-
-    it('clasifica el estado como el display del detalle (D41)', async () => {
-      // `warning` se pinta como `accent` (bg-accent/20 + text-accent-text).
-      const pendiente = await pintar(col, { row: { status: 'PENDIENTE' } });
-      expect(pendiente.querySelector('app-badge')?.className).toContain('bg-accent/20');
-
-      const entregado = await pintar(col, { row: { status: 'ENTREGADO' } });
-      expect(entregado.querySelector('app-badge')?.className).toContain('bg-success');
-
-      const cancelado = await pintar(col, { row: { status: 'Cancelado' } });
-      expect(cancelado.querySelector('app-badge')?.className).toContain('bg-danger');
-
-      const otro = await pintar(col, { row: { status: 'Vigente' } });
-      expect(otro.querySelector('app-badge')?.className).toContain('bg-neutral');
-    });
-
-    it('un select pinta la etiqueta de la opción, no el valor crudo', async () => {
-      const nodo = await pintar(col, {
-        row: { status: 'preparacion' },
-        fields: [
-          {
-            key: 'status',
-            label: 'Estado',
-            type: 'select',
-            options: [
-              { value: 'preparacion', label: 'En preparación' },
-              { value: 'entregado', label: 'Entregado' },
-            ],
-          },
-        ],
-      });
-      expect(nodo.textContent).toContain('En preparación');
-    });
-
-    it('el vacío sale «Sin dato» en danger', async () => {
-      const nodo = await pintar(col, { row: { status: '' } });
-      expect(nodo.textContent).toContain('Sin dato');
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-danger');
-    });
-
-    it('un booleano usa trueLabel/falseLabel del campo', async () => {
-      const nodo = await pintar(col, {
-        row: { status: true },
-        fields: [{ key: 'status', label: 'Estado', type: 'boolean', trueLabel: 'Vigente' }],
-      });
-      expect(nodo.textContent).toContain('Vigente');
-      expect(nodo.querySelector('app-badge')?.className).toContain('bg-success');
-    });
-  });
-
-  describe('boolean', () => {
-    const col: ListColumn = { key: 'active', label: 'Activo', format: 'boolean' };
-    const booleano = { key: 'active', label: 'Activo', type: 'boolean' as const };
-
-    it('con permiso y campo booleano dibuja el interruptor', async () => {
-      const nodo = await pintar(col, {
-        row: { active: true },
-        fields: [booleano],
-        canUpdate: true,
-      });
-      const box = nodo.querySelector<HTMLInputElement>('input[type="checkbox"]');
-      expect(box, 'debe dibujarse el interruptor').not.toBeNull();
-      expect(box?.checked).toBe(true);
-      expect(box?.getAttribute('aria-label')).toBe('Activo: Una fila');
-    });
-
-    it('sin permiso cae al badge', async () => {
-      const nodo = await pintar(col, { row: { active: true }, fields: [booleano] });
-      expect(nodo.querySelector('input[type="checkbox"]')).toBeNull();
-      expect(nodo.textContent).toContain('Sí');
-    });
-
-    it('mientras la fila guarda, el interruptor queda bloqueado', async () => {
-      const nodo = await pintar(col, {
-        row: { active: false },
-        fields: [booleano],
-        canUpdate: true,
-        saving: true,
-      });
-      const box = nodo.querySelector<HTMLInputElement>('input[type="checkbox"]');
-      expect(box?.disabled, 'mientras guarda, la fila está bloqueada').toBe(true);
-    });
-
-    it('al alternar escribe por la celda', async () => {
-      const toggle = vi.fn();
-      const nodo = await pintar(col, {
-        row: { active: false },
-        fields: [booleano],
-        canUpdate: true,
-        toggle,
-      });
-      nodo.querySelector<HTMLInputElement>('input[type="checkbox"]')!.click();
-      expect(toggle).toHaveBeenCalledWith(true);
-    });
-  });
-
-  describe('thumbnail', () => {
-    const col: ListColumn = { key: 'image_url', label: 'Imagen', format: 'thumbnail' };
-
-    it('pinta la imagen con su alt', async () => {
-      const nodo = await pintar(col, { row: { image_url: '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('');
-    });
-
-    it('toma el primer item de images[] con su image_alt', async () => {
-      const nodo = await pintar(
-        { key: 'images', label: 'Imágenes', format: 'thumbnail' },
-        { row: { images: [{ image_url: 'https://x.test/b.png', image_alt: 'Frente' }] } },
-      );
-      expect(nodo.querySelector('img')?.getAttribute('src')).toBe('https://x.test/b.png');
-      expect(nodo.querySelector('img')?.getAttribute('alt')).toBe('Frente');
-    });
-
-    it('sin URL pinta el guion', async () => {
-      const nodo = await pintar(col, { row: { image_url: '' } });
-      expect(nodo.textContent).toContain('—');
-      expect(nodo.querySelector('img')).toBeNull();
-    });
-  });
-});