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

package/src/lib/shared/components/toast/toast.ts

@@ -1,58 +0,0 @@
-import { Component, input, output } from '@angular/core';
-import { LucideCircleCheck, LucideCircleX, LucideInfo, LucideX } from '@lucide/angular';
-
-export type ToastKind = 'success' | 'error' | 'info';
-
-/** Estructuralmente idéntico a `core`'s `Toast` — no importa `core`. */
-export interface ToastItem {
-  id: number;
-  kind: ToastKind;
-  message: string;
-}
-
-/**
- * Contenedor visual de toasts: fijo arriba a la derecha, región `status`
- * viva (polite) para que se anuncien los mensajes. Recibe los toasts por
- * `input()` desde quien sí tiene `NotificationService` (Fase 7).
- */
-@Component({
-  selector: 'app-toast',
-  imports: [LucideCircleCheck, LucideCircleX, LucideInfo, LucideX],
-  host: {
-    class: 'pointer-events-none fixed right-4 top-4 z-50 flex w-full max-w-sm flex-col gap-2',
-    role: 'status',
-    'aria-live': 'polite',
-  },
-  template: `
-    @for (toast of toasts(); track toast.id) {
-      <div
-        class="pointer-events-auto flex items-start gap-3 border-l-4 bg-surface-raised p-4 shadow-lg"
-        [class.border-l-success]="toast.kind === 'success'"
-        [class.border-l-danger]="toast.kind === 'error'"
-        [class.border-l-primary]="toast.kind === 'info'"
-      >
-        @if (toast.kind === 'success') {
-          <svg lucideCircleCheck size="18" class="mt-0.5 shrink-0 text-success" />
-        } @else if (toast.kind === 'error') {
-          <svg lucideCircleX size="18" class="mt-0.5 shrink-0 text-danger" />
-        } @else {
-          <svg lucideInfo size="18" class="mt-0.5 shrink-0 text-primary" />
-        }
-        <p class="flex-1 text-sm font-medium">{{ toast.message }}</p>
-        <button
-          type="button"
-          class="flex min-h-11 min-w-11 items-center justify-center rounded text-neutral hover:bg-neutral/10 focus-visible:outline-2 focus-visible:outline-primary lg:min-h-0 lg:min-w-0"
-          [attr.aria-label]="closeLabel()"
-          (click)="dismissed.emit(toast.id)"
-        >
-          <svg lucideX size="18" />
-        </button>
-      </div>
-    }
-  `,
-})
-export class Toast {
-  readonly toasts = input<ToastItem[]>([]);
-  readonly closeLabel = input('Cerrar');
-  readonly dismissed = output<number>();
-}

package/src/lib/shared/utils/col-span.ts

@@ -1,25 +0,0 @@
-/**
- * Anchos de columna del layout (base.md §4: `width` 1–12).
- *
- * `sm:col-span-*` como literales: Tailwind v4 solo genera las clases que ve
- * en el código, así que no pueden construirse por concatenación.
- */
-const COL_SPANS: Record<number, string> = {
-  1: 'sm:col-span-1',
-  2: 'sm:col-span-2',
-  3: 'sm:col-span-3',
-  4: 'sm:col-span-4',
-  5: 'sm:col-span-5',
-  6: 'sm:col-span-6',
-  7: 'sm:col-span-7',
-  8: 'sm:col-span-8',
-  9: 'sm:col-span-9',
-  10: 'sm:col-span-10',
-  11: 'sm:col-span-11',
-  12: 'sm:col-span-12',
-};
-
-/** Clase `sm:col-span-*` para el ancho del campo (por defecto: 12). */
-export function colSpanClass(width: number | undefined): string {
-  return COL_SPANS[width ?? 12];
-}

package/src/lib/shared/utils/condition-evaluator.ts

@@ -1,53 +0,0 @@
-import type { FieldCondition } from '../../core/models/schema.model';
-
-/**
- * Evaluador de condiciones `visibleWhen` / `readonlyWhen` (base.md §4):
- * comparaciones simples (igual, distinto, está vacío, contiene) sobre otros
- * campos del mismo nivel o del registro raíz.
- *
- * Nota de arquitectura: la importación de `FieldCondition` es SOLO de tipo
- * (se elimina en compilación) — no hay dependencia de runtime con `core`.
- */
-
-/** Resuelve una condición. Se resuelve contra el nivel propio; si la clave
- * no existe ahí, contra la raíz del registro. */
-export function evaluateCondition(
-  condition: FieldCondition,
-  siblingValues: Record<string, unknown>,
-  rootValues: Record<string, unknown> = {},
-): boolean {
-  const source = condition.field in siblingValues ? siblingValues : rootValues;
-  const actual = source[condition.field];
-  const expected = condition.value;
-
-  switch (condition.operator) {
-    case 'eq':
-      return actual === expected;
-    case 'ne':
-      return actual !== expected;
-    case 'empty':
-      return isEmpty(actual);
-    case 'contains':
-      return contains(actual, expected);
-  }
-}
-
-function isEmpty(value: unknown): boolean {
-  if (value === undefined || value === null || value === '') {
-    return true;
-  }
-  if (Array.isArray(value)) {
-    return value.length === 0;
-  }
-  return false;
-}
-
-function contains(actual: unknown, expected: unknown): boolean {
-  if (typeof actual === 'string') {
-    return actual.includes(String(expected));
-  }
-  if (Array.isArray(actual)) {
-    return actual.includes(expected);
-  }
-  return false;
-}

package/src/lib/shared/utils/depends-on.ts

@@ -1,48 +0,0 @@
-import type { FieldSchema } from '../../core/models/schema.model';
-import { seedFieldValue } from './seed';
-
-/**
- * Enlaces de selección dependiente (guía §1, plan 6.6).
- *
- * `condition-evaluator.ts` sólo RESUELVE condiciones (`visibleWhen` /
- * `readonlyWhen`): no resetea nada. Acá se levanta el mapa de «cuando el
- * padre cambie, limpiar el hijo» que `form-view` observa con un `effect`.
- *
- * Alcance: raíz y `group` (contenedores estáticos). Los ítems de un `list`
- * se crean y borran mientras se edita y sus rutas no son estables — un
- * dependiente dentro de una lista queda sin resetear, así que no se promete.
- */
-export interface DependsOnLink {
-  /** Ruta de contenedores desde la raíz: `[]` en la raíz, `['contacto']` en un grupo. */
-  container: string[];
-  childKey: string;
-  parentKey: string;
-  /** Valor con el que se limpia el hijo (el default del schema). */
-  resetValue: unknown;
-  /** Clave estable del enlace para el snapshot de comparación. */
-  id: string;
-}
-
-export function collectDependsOn(
-  fields: readonly FieldSchema[],
-  container: string[] = [],
-): DependsOnLink[] {
-  const links: DependsOnLink[] = [];
-  for (const field of fields) {
-    if (field.type === 'group') {
-      links.push(...collectDependsOn(field.fields, [...container, field.key]));
-      continue;
-    }
-    if (field.dependsOn === undefined) {
-      continue;
-    }
-    links.push({
-      container,
-      childKey: field.key,
-      parentKey: field.dependsOn,
-      resetValue: seedFieldValue(field),
-      id: `${container.join('.')}.${field.key}<-${field.dependsOn}`,
-    });
-  }
-  return links;
-}

package/src/lib/shared/utils/dialog-focus.ts

@@ -1,28 +0,0 @@
-/**
- * Utilidades de foco para los diálogos (`modal` y `drawer`).
- *
- * Los dos componentes comparten el mismo contrato: atrapan el Tab dentro del
- * panel para que el foco no se pierda detrás del fondo oscuro. Tener el
- * selector y el test de visibilidad en un solo sitio evita que los dos
- * diálogos diverjan.
- */
-
-/** Candidatos a foco dentro del diálogo (el orden del foco del navegador). */
-export const FOCUSABLE =
-  'a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
-
-/**
- * ¿Se puede enfocar este elemento ahora mismo?
- *
- * No se usa `offsetParent`: en jsdom es siempre `null` y el atrapado del Tab
- * quedaría sin opérculo en los tests. `checkVisibility` da la respuesta
- * exacta en navegador; si no existe (jsdom), se confía en lo que hay en el
- * DOM y sólo se descarta lo marcado `hidden`.
- */
-export function isVisibleNow(element: HTMLElement): boolean {
-  if (element.hasAttribute('hidden') || element.closest('[hidden]') !== null) {
-    return false;
-  }
-  const check = (element as { checkVisibility?: (options?: unknown) => boolean }).checkVisibility;
-  return typeof check !== 'function' || check.call(element);
-}

package/src/lib/shared/utils/field-path.ts

@@ -1,49 +0,0 @@
-/**
- * Lectura de valores por ruta (ej. `faq[2].answer`, `address.city`) —
- * celdas del listado y valores anidados de los singleton (base.md §10).
- */
-
-/** Segmentos de una ruta: claves de objeto y índices de arreglo. */
-export type PathSegment = string | number;
-
-/** `faq[2].answer` → `['faq', 2, 'answer']`. */
-export function parsePath(path: string): PathSegment[] {
-  const segments: PathSegment[] = [];
-  for (const part of path.split('.')) {
-    if (part === '') {
-      continue;
-    }
-    const match = /^([^[\]]*)((?:\[\d+\])+)$/.exec(part);
-    if (match) {
-      const key = match[1];
-      if (key !== '') {
-        segments.push(key);
-      }
-      for (const bracket of match[2].matchAll(/\[(\d+)\]/g)) {
-        segments.push(Number(bracket[1]));
-      }
-    } else {
-      segments.push(part);
-    }
-  }
-  return segments;
-}
-
-/** Lee el valor en `path`; `undefined` si algún tramo no existe. */
-export function getValue<T = unknown>(source: unknown, path: string): T | undefined {
-  let current: unknown = source;
-  for (const segment of parsePath(path)) {
-    if (current === null || current === undefined || typeof current !== 'object') {
-      return undefined;
-    }
-    if (typeof segment === 'number') {
-      if (!Array.isArray(current)) {
-        return undefined;
-      }
-      current = current[segment];
-    } else {
-      current = (current as Record<string, unknown>)[segment];
-    }
-  }
-  return current as T;
-}

package/src/lib/shared/utils/gap-sorting.ts

@@ -1,144 +0,0 @@
-/**
- * Ordenamiento con huecos (base.md §8).
- *
- * Reglas:
- * - Posiciones enteras con separación fija (paso 1000: 1000, 2000, 3000…).
- * - Mover entre dos vecinos → punto medio; solo cambia ese elemento.
- * - Mover al inicio → la mitad de la posición del primero.
- * - Mover al final → la del último + paso.
- * - Lista vacía → el paso.
- * - Si los vecinos quedan sin espacio (diferencia < 2) → rebalanceo:
- *   se renumera toda la lista con el paso original conservando el orden
- *   y luego se aplica el movimiento.
- * - Nuevos elementos → última posición + paso.
- *
- * El usuario nunca ve los números; la UI ordena por `position` ascendente.
- */
-
-/** Separación fija entre posiciones. */
-export const GAP = 1000;
-
-export interface PositionedItem {
-  key: string;
-  position: number;
-}
-
-export interface PositionChange {
-  key: string;
-  position: number;
-}
-
-export interface ReorderResult {
-  /** `true` → hubo rebalanceo: `changes` contiene el lote completo renumerado. */
-  rebalanced: boolean;
-  /** Cambios a enviar: solo el elemento movido, o el lote completo. */
-  changes: PositionChange[];
-}
-
-/** Punto medio entre dos vecinos (solo el elemento movido cambia). */
-export function moveBetween(prevPosition: number, nextPosition: number): number {
-  return Math.floor((prevPosition + nextPosition) / 2);
-}
-
-/** Mover al inicio: la mitad de la posición del primero. */
-export function moveToStart(firstPosition: number): number {
-  return Math.floor(firstPosition / 2);
-}
-
-/** Mover al final: la del último + paso. */
-export function moveToEnd(lastPosition: number): number {
-  return lastPosition + GAP;
-}
-
-/** Posición de un elemento nuevo: al final (lista vacía → el paso). */
-export function appendPosition(items: PositionedItem[]): number {
-  const sorted = sortItems(items);
-  if (sorted.length === 0) {
-    return GAP;
-  }
-  return moveToEnd(sorted[sorted.length - 1].position);
-}
-
-/** ¿Falta espacio para insertar en `targetIndex`? (base.md §8) */
-export function needsRebalance(
-  items: PositionedItem[],
-  movingKey: string,
-  targetIndex: number,
-): boolean {
-  const without = sortItems(items.filter((item) => item.key !== movingKey));
-  if (without.length === 0) {
-    return false; // lista vacía → el paso siempre cabe
-  }
-  const index = clamp(targetIndex, 0, without.length);
-  if (index === without.length) {
-    return false; // al final → +paso siempre cabe
-  }
-  if (index === 0) {
-    const first = without[0];
-    return first.position - moveToStart(first.position) < 2;
-  }
-  const prev = without[index - 1];
-  const next = without[index];
-  return next.position - prev.position < 2;
-}
-
-/** Renumera la lista completa con el paso original, conservando el orden. */
-export function rebalance(items: PositionedItem[], gap: number = GAP): PositionChange[] {
-  return sortItems(items).map((item, index) => ({
-    key: item.key,
-    position: (index + 1) * gap,
-  }));
-}
-
-/**
- * Calcula el resultado de soltar `movingKey` en `targetIndex`
- * (índice que ocupará en la lista SIN el elemento movido, ya ordenada).
- */
-export function computeMove(
-  items: PositionedItem[],
-  movingKey: string,
-  targetIndex: number,
-): ReorderResult {
-  const sorted = sortItems(items);
-  if (!sorted.some((item) => item.key === movingKey)) {
-    throw new Error(`Elemento no encontrado: ${movingKey}`);
-  }
-  const without = sorted.filter((item) => item.key !== movingKey);
-  const index = clamp(targetIndex, 0, without.length);
-
-  if (needsRebalance(sorted, movingKey, targetIndex)) {
-    // Renumerar toda la lista y luego aplicar el movimiento.
-    const renumbered = rebalance(without);
-    const position = positionFor(renumbered, index);
-    return {
-      rebalanced: true,
-      changes: [...renumbered, { key: movingKey, position }],
-    };
-  }
-
-  return {
-    rebalanced: false,
-    changes: [{ key: movingKey, position: positionFor(without, index) }],
-  };
-}
-
-function positionFor(without: PositionChange[], index: number): number {
-  if (without.length === 0) {
-    return GAP;
-  }
-  if (index === 0) {
-    return moveToStart(without[0].position);
-  }
-  if (index === without.length) {
-    return moveToEnd(without[without.length - 1].position);
-  }
-  return moveBetween(without[index - 1].position, without[index].position);
-}
-
-function sortItems(items: PositionedItem[]): PositionedItem[] {
-  return [...items].sort((a, b) => a.position - b.position);
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.min(Math.max(value, min), max);
-}

package/src/lib/shared/utils/seed.spec.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type { FieldSchema } from '../../core/models/schema.model';
-import { register } from '../../core/registry/render-registry';
-import { fieldDescriptors } from '../../fields/descriptors';
-import { seedValue, type SeedKind } from './seed';
-
-/**
- * D32 · R3.8 — la siembra vive en el descriptor, no en un `switch`.
- *
- * Tres cosas distintas, ninguna cosmética:
- *
- *  1. **Oro por descriptor** — cada tipo registrado siembra la forma que su
- *     `seed` declara. Si alguien cambia `'number'` por `'string'` en un
- *     descriptor, el tipo empieza a nacer en `''` y este test lo dice antes
- *     que un formulario en producción.
- *  2. **Degradación** — un tipo fuera del catálogo siembra `undefined`, lo
- *     mismo que hace el render (R1.10): no se pinta, no existe.
- *  3. **Fail-loud** — un descriptor registrado *sin* `seed` lanza, en vez de
- *     sembrar `undefined` en silencio.
- *
- * El vitest aísla este fichero, así que el descriptor falso registrado en el
- * último test no se filtra al resto de la suite.
- */
-describe('seedValue — siembra declarada por el descriptor', () => {
-  const FORMA: Record<SeedKind, unknown> = {
-    string: '',
-    number: null,
-    boolean: false,
-    array: [],
-    // `group` con `fields: []` siembra un objeto vacío.
-    recursive: {},
-  };
-
-  const campos = fieldDescriptors.filter((descriptor) => descriptor.kind === 'field');
-
-  for (const descriptor of campos) {
-    it(`«${descriptor.type}» siembra la forma «${descriptor.seed}»`, () => {
-      const campo = {
-        key: 'k',
-        label: 'K',
-        type: descriptor.type,
-        fields: [],
-      } as unknown as FieldSchema;
-      expect(seedValue(campo)).toEqual(FORMA[descriptor.seed as SeedKind]);
-    });
-  }
-
-  it('un tipo fuera del catálogo siembra `undefined` y no revienta', () => {
-    const campo = { key: 'k', label: 'K', type: 'sombrero' } as unknown as FieldSchema;
-    expect(seedValue(campo)).toBeUndefined();
-  });
-
-  it('un descriptor sin `seed` lanza en sembrar', () => {
-    register('field', {
-      kind: 'field',
-      type: 'sin-siembra',
-      since: '1.0',
-      load: () => Promise.resolve(class Vacia {}),
-    });
-    const campo = { key: 'k', label: 'K', type: 'sin-siembra' } as unknown as FieldSchema;
-    expect(() => seedValue(campo)).toThrow(/no declara `seed`/);
-  });
-});

package/src/lib/shared/utils/seed.ts

@@ -1,149 +0,0 @@
-import type { FieldSchema, GroupField } from '../../core/models/schema.model';
-import { get } from '../../core/registry/render-registry';
-
-/**
- * Forma del valor inicial que siembra un campo (D32 · R3.8).
- *
- * Son **todos** los valores posibles del dominio: un campo de formulario
- * nuevo nace como cadena, número, booleano, lista o como contenedor que
- * siembra sus hijos. Si un tipo llegara a necesitar otra forma, ampliar este
- * `type` obliga a compilar el `switch` de `seedValue` — que es exactamente
- * el fail-loud que la regla 4 pide.
- */
-export type SeedKind = 'string' | 'number' | 'boolean' | 'array' | 'recursive';
-
-/**
- * Siembra del modelo del formulario: un valor por defecto para CADA campo
- * declarado en el schema (base.md §10).
- *
- * Compartido entre `form-model` (crear/recargar) y los componentes de lista
- * (crear ítems nuevos con la forma de sus `itemFields`).
- */
-
-/**
- * Valor inicial cuando el schema no declara `default`.
- *
- * **D32 · ya no despacha por tipo.** El `switch` de 20 ramas que obligaba a
- * editar este fichero al añadir un campo — y que §0 contaba como tocar el
- * motor — pasa a resolver el nombre que declara el propio descriptor
- * (`RenderDescriptor.seed`). «Añadir un tipo» queda en carpeta + manifiesto
- * + unión: este archivo no se entera.
- *
- * Dos salidas distintas, ninguna silenciosa:
- *
- *  · **tipo fuera del catálogo** ⇒ `undefined`, la misma degradación
- *    controlada que el render (R1.10): el campo no se pinta, así que su
- *    valor no existe;
- *  · **descriptor sin `seed`** ⇒ lanza. Es un error de programación que
- *    `core/registry/contract.spec.ts` detecta en CI antes de llegar acá.
- */
-export function seedValue(field: FieldSchema): unknown {
-  const descriptor = get('field', field.type);
-
-  if (!descriptor) {
-    return undefined;
-  }
-  if (!descriptor.seed) {
-    throw new Error(`[seed] el descriptor de "${field.type}" no declara \`seed\`.`);
-  }
-
-  switch (descriptor.seed) {
-    case 'string':
-      return '';
-    case 'number':
-      return null;
-    case 'boolean':
-      return false;
-    case 'array':
-      return [];
-    case 'recursive':
-      return seedHijos(field, descriptor.seed);
-  }
-}
-
-/**
- * Siembra recursiva de un contenedor.
- *
- * El único `seed` recursivo del catálogo es `group`, pero el registro no lo
- * sabe — sólo lleva un nombre. El estrechado se comprueba aquí y **falla
- * ruidoso** si algún día un tipo declara `'recursive'` sin traer subcampos.
- */
-function seedHijos(field: FieldSchema, seed: 'recursive'): unknown {
-  if (seed !== 'recursive' || !esGrupo(field)) {
-    throw new Error(`[seed] "${field.type}" declara \`seed: 'recursive'\` pero no trae subcampos.`);
-  }
-  return seedFields(field.fields);
-}
-
-/** Estrechado de forma, no de despacho: no decide qué hacer, sólo accede. */
-function esGrupo(field: FieldSchema): field is GroupField {
-  return field.type === 'group';
-}
-
-/** Valor sembrado de un campo, fusionando `default` con la forma del schema. */
-export function seedFieldValue(field: FieldSchema): unknown {
-  if (field.default === undefined) {
-    return seedValue(field);
-  }
-  if (field.type === 'group' && isRecord(field.default)) {
-    // Un `default` de grupo podría traer claves incompletas: los hijos se
-    // acceden por árbol, así que la forma completa es obligatoria.
-    return { ...seedFields(field.fields), ...field.default };
-  }
-  if (field.type === 'list' && Array.isArray(field.default)) {
-    return field.default.map((item) =>
-      isRecord(item) ? { ...seedFields(field.itemFields), ...item } : item,
-    );
-  }
-  return field.default;
-}
-
-/**
- * Siembra recursiva: los `group` anidan sus propios campos. Exportada porque
- * la lista crea sus ítems nuevos con la misma forma (`base.md §6`).
- */
-export function seedFields(fields: readonly FieldSchema[]): Record<string, unknown> {
-  const model: Record<string, unknown> = {};
-  for (const field of fields) {
-    model[field.key] = seedFieldValue(field);
-  }
-  return model;
-}
-
-/**
- * Fusiona el registro leído con la forma sembrada del schema.
- *
- * El backend puede omitir claves (p. ej. un ítem guardado antes de que el
- * schema agregara un campo): sin esta fusión el árbol no tendría nodo para
- * ese campo y `childTree` lanzaría al renderizar. Lo ausente toma su
- * `default` y los extras del registro (p. ej. `position` de los ítems) se
- * conservan.
- */
-export function mergeRecord(
-  fields: readonly FieldSchema[],
-  record: Record<string, unknown>,
-): Record<string, unknown> {
-  const merged: Record<string, unknown> = {};
-  for (const field of fields) {
-    const incoming = record[field.key];
-    if (field.type === 'group') {
-      merged[field.key] = isRecord(incoming)
-        ? mergeRecord(field.fields, incoming)
-        : seedFieldValue(field);
-      continue;
-    }
-    if (field.type === 'list') {
-      const itemSeed = seedFields(field.itemFields);
-      merged[field.key] = Array.isArray(incoming)
-        ? incoming.map((item) => (isRecord(item) ? { ...itemSeed, ...item } : item))
-        : seedFieldValue(field);
-      continue;
-    }
-    merged[field.key] = incoming !== undefined ? incoming : seedFieldValue(field);
-  }
-  return merged;
-}
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}

package/src/lib/shared/utils/slugify.ts

@@ -1,13 +0,0 @@
-/**
- * Normaliza texto a slug: minúsculas, sin acentos, separados por guiones.
- * Ej.: `Lomo Saltado Ñoño` → `lomo-saltado-nonio`.
- */
-export function slugify(value: string): string {
-  return value
-    .normalize('NFD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .toLowerCase()
-    .trim()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}

package/src/lib/shared/utils/validators.ts

@@ -1,41 +0,0 @@
-/**
- * Validadores puros sobre valores (base.md §4): longitud por palabras.
- * Devuelven `null` cuando el valor es válido o cuando no aplica.
- * (Longitud por caracteres, patrón y rango los aplica `@angular/forms/signals`
- * vía `form-schema.ts`: `minLengthRule`/`maxLengthRule`/`patternRule`/`minRule`.)
- *
- * Reglas comunes:
- * - Valor vacío (`undefined` / `null` / `''`) → `null`: la obligatoriedad
- *   la maneja `required` aparte. Solo espacios NO cuenta como vacío.
- * - Valores de otro tipo → `null` (no validan aquí; los cubre el campo).
- *
- * Los mensajes se muestran tal cual bajo el campo (Fase 10), en español.
- */
-
-export function validateMinWords(value: unknown, min: number): string | null {
-  const words = wordCount(value);
-  if (words === null) {
-    return null;
-  }
-  return words >= min ? null : `Debe tener al menos ${min} palabras.`;
-}
-
-export function validateMaxWords(value: unknown, max: number): string | null {
-  const words = wordCount(value);
-  if (words === null) {
-    return null;
-  }
-  return words <= max ? null : `Como máximo ${max} palabras.`;
-}
-
-function isEmpty(value: unknown): boolean {
-  return value === undefined || value === null || value === '';
-}
-
-/** Conteo de palabras; `null` si el valor no es texto o está vacío. */
-function wordCount(value: unknown): number | null {
-  if (isEmpty(value) || typeof value !== 'string') {
-    return null;
-  }
-  return value.trim().split(/\s+/).filter(Boolean).length;
-}