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

package/src/lib/views/composer/view-context.spec.ts

@@ -1,117 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { toSignal } from '@angular/core/rxjs-interop';
-import type { ParamMap } from '@angular/router';
-import { describe, expect, it, vi } from 'vitest';
-
-import type {
-  ResourceSchema,
-  SelectionBinding,
-  UiViewDescriptor,
-} from '../../core/models/schema.model';
-import { createViewContext, instanceIdFor, syntheticRoute, virtualSchemaFor } from './view-context';
-
-const schemaBase: ResourceSchema = {
-  id: 'demo',
-  label: 'Demo',
-  labelPlural: 'Demos',
-  kind: 'collection',
-  endpoint: {},
-  keyField: 'id',
-  titleField: 'name',
-  listColumns: [],
-  fields: [],
-  uiViews: {
-    rows: { type: 'list' },
-  },
-};
-
-const nodoHijo: UiViewDescriptor = {
-  type: 'kanban',
-  path: '',
-  config: { groupField: 'x', columns: [{ value: 'a', label: 'A' }] },
-};
-
-describe('instanceIdFor', () => {
-  it('concatena padre/hijo con separador estable', () => {
-    expect(instanceIdFor('panel', 'cal')).toBe('panel/cal');
-    expect(instanceIdFor('a/b', 'c')).toBe('a/b/c');
-  });
-});
-
-describe('virtualSchemaFor', () => {
-  it('añade uiViews[instanceId] sin mutar el schema original', () => {
-    const clon = virtualSchemaFor(schemaBase, 'panel/cal', nodoHijo);
-    expect(clon.uiViews?.['panel/cal']).toBe(nodoHijo);
-    expect(schemaBase.uiViews?.['panel/cal']).toBeUndefined();
-    expect(Object.keys(schemaBase.uiViews ?? {})).toEqual(['rows']);
-  });
-
-  it('conserva las uiViews existentes (lookup estilo hoja sigue funcionando)', () => {
-    const clon = virtualSchemaFor(schemaBase, 'panel/cal', nodoHijo);
-    expect(clon.uiViews?.['rows']).toBe(schemaBase.uiViews?.['rows']);
-    expect(clon.id).toBe('demo');
-  });
-});
-
-describe('createViewContext / syntheticRoute', () => {
-  it('sin emit la clave queda ausente (comportamiento local inerte)', () => {
-    const ctx = createViewContext({ resourceId: 'demo', uiView: 'rows', viewType: 'list' });
-    expect('emit' in ctx).toBe(false);
-  });
-
-  it('con emit la clave existe y es una función', () => {
-    const ctx = createViewContext(
-      { resourceId: 'demo', uiView: 'rows', viewType: 'list' },
-      vi.fn(),
-    );
-    expect(typeof ctx.emit).toBe('function');
-  });
-
-  // R9.9.4: la hoja necesita ver el binding declarado (cualquier mode),
-  // no sólo el `emit` — sin `select` en el payload la decision table no
-  // puede distinguir «sin declaración» de `none`/`inline`.
-  it('con select declarado la clave viaja en el payload', () => {
-    const binding: SelectionBinding = { on: 'open', mode: 'inline' };
-    const ctx = createViewContext({
-      resourceId: 'demo',
-      uiView: 'rows',
-      viewType: 'list',
-      select: binding,
-    });
-    expect(ctx.select).toEqual(binding);
-  });
-
-  it('sin select declarado la clave queda ausente (comportamiento local inerte)', () => {
-    const ctx = createViewContext({ resourceId: 'demo', uiView: 'rows', viewType: 'list' });
-    expect('select' in ctx).toBe(false);
-  });
-});
-
-describe('syntheticRoute', () => {
-  it('emite síncrono: toSignal(..., requireSync) de la hoja lee el payload sin input bindings', () => {
-    const ctx = createViewContext(
-      { resourceId: 'demo', uiView: 'panel/cal', viewType: 'kanban' },
-      vi.fn(),
-    );
-    const r = syntheticRoute(ctx);
-    const data = TestBed.runInInjectionContext(() => toSignal(r.data, { requireSync: true }));
-    expect(data()).toEqual(ctx);
-    expect(typeof data()['emit']).toBe('function');
-  });
-});
-
-// ── R9.9.3 · ruta sintética completa (hojas tipo ResourcePage) ──
-
-describe('syntheticRoute', () => {
-  it('incluye paramMap síncrono además de data (ResourcePage lee ambos)', () => {
-    const ruta = syntheticRoute({ resourceId: 'orders', uiView: 'x', viewType: 'list' });
-    let params: ParamMap | null = null;
-    ruta.paramMap.subscribe((p) => (params = p));
-    expect(params).not.toBeNull();
-    expect(params!.get('key')).toBeNull();
-
-    let data: unknown = null;
-    ruta.data.subscribe((d) => (data = d));
-    expect(data).toMatchObject({ resourceId: 'orders', viewType: 'list' });
-  });
-});

package/src/lib/views/composer/view-context.ts

@@ -1,109 +0,0 @@
-import { convertToParamMap, type ActivatedRoute } from '@angular/router';
-import { of } from 'rxjs';
-
-import type {
-  ResourceSchema,
-  SelectionBinding,
-  UiViewDescriptor,
-} from '../../core/models/schema.model';
-
-/**
- * R9.9 · D1 — Canal ViewContext.
- *
- * El shell monta hojas con `loadComponent` SIN bindings de input, así que el
- * único canal que una hoja recibe es `route.data`. Este módulo es la fábrica
- * ÚNICA de ese payload para ambos productores:
- *
- * - Lado embebido (`ViewSlot`, slice 3): `syntheticRoute(payload)` — una
- *   `ActivatedRoute` sintética cuyo `data` emite síncrono, de modo que
- *   `toSignal(route.data, {requireSync:true})` sigue funcionando igual.
- * - Lado ruta (`shell.routes`): `resolve:{viewContext}` devuelve el mismo
- *   payload con el `emit` ligado en contexto de inyección.
- *
- * Cero reescritura en las hojas: leen `schema`/`resourceId`/`uiView` como
- * siempre. Un `emit` ausente significa «sin comportamiento declarado ⇒ el
- * comportamiento local sigue» — nunca es un error.
- */
-
-/** Evento de selección que una hoja emite cuando hay `select` declarado. */
-export interface SelectionEvent {
-  /** Recurso del registro seleccionado. */
-  resource: string;
-  /** Clave estable del registro — la ÚNICA identidad que viaja al router. */
-  key: string;
-  /** Disparador que activó la transición (`on` del binding). */
-  action: string;
-}
-
-/** Callback de selección entregado a la hoja a través del canal. */
-export type SelectionEmitter = (event: SelectionEvent) => void;
-
-/**
- * Payload del canal: las mismas claves planas que una hoja montada por ruta
- * lee en `route.data`. `schema` explícito sólo existe en el lado embebido
- * (schema virtual); montado por ruta la hoja lo resuelve vía `resourceId`.
- */
-export interface ViewContextData {
-  schema?: ResourceSchema;
-  resourceId: string;
-  uiView: string;
-  viewType: string;
-  /**
-   * Profundidad de ESTA instancia (raíz ⇒ campo ausente ⇒ 0). El productor
-   * embebido (`ViewSlot`) la fija para que un contenedor anidado pase
-   * `depth + 1` a sus propios slots y el tope `MAX_DEPTH` se cumpla en
-   * runtime aunque el validador no llegue a correr (defensa en profundidad).
-   */
-  depth?: number;
-  /**
-   * Binding `select` declarado por la vista (cualquier mode). El `emit`
-   * sólo existe para `mode:'route'`; la hoja necesita VER el binding para
-   * aplicar la decision table (R9.9.4): ausente ⇒ comportamiento local,
-   * `inline` ⇒ selección local, `none` ⇒ no-op explícito.
-   */
-  select?: SelectionBinding;
-  emit?: SelectionEmitter;
-}
-
-/** Identidad estable de una instancia embebida: `parentId + '/' + childId`. */
-export function instanceIdFor(parentId: string, childId: string): string {
-  return `${parentId}/${childId}`;
-}
-
-/**
- * Schema virtual por instancia: clona el schema y expone la config del hijo
- * bajo `uiViews[instanceId]`, de modo que la lookup existente
- * `schema.uiViews[route.uiView]` de las hojas resuelve la config del nodo
- * SIN tocar ninguna hoja. No muta el schema original.
- */
-export function virtualSchemaFor(
-  schema: ResourceSchema,
-  instanceId: string,
-  view: UiViewDescriptor,
-): ResourceSchema {
-  return { ...schema, uiViews: { ...schema.uiViews, [instanceId]: view } };
-}
-
-/**
- * `ActivatedRoute` sintética para hijos embebidos. `of()` emite síncrono ⇒
- * `toSignal(..., {requireSync:true})` no revienta. El cast es único y
- * documentado (D1): sólo se consume `data`, igual que una ruta real.
- */
-export function syntheticRoute(data: ViewContextData): ActivatedRoute {
-  // `paramMap` además de `data`: hojas tipo `ResourcePage` (list/detail/
-  // dashboard) hacen `toSignal(route.paramMap, {requireSync:true})` y
-  // `paramMap.subscribe(...)`. Vacío = embebido sin clave de registro
-  // (nunca un detail-key implícito); la clave real viaja en el payload.
-  return {
-    data: of(data),
-    paramMap: of(convertToParamMap({})),
-  } as unknown as ActivatedRoute;
-}
-
-/** Construye el payload; `emit` sólo se agrega si existe (clave ausente si no). */
-export function createViewContext(
-  base: Omit<ViewContextData, 'emit'>,
-  emit?: SelectionEmitter,
-): ViewContextData {
-  return emit === undefined ? { ...base } : { ...base, emit };
-}

package/src/lib/views/composer/view-slot.spec.ts

@@ -1,130 +0,0 @@
-import { Component } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { ActivatedRoute } from '@angular/router';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import type { ResourceSchema, ViewChildNode } from '../../core/models/schema.model';
-import { register, unregister } from '../../core/registry/render-registry';
-import { ViewSlot } from './view-slot';
-
-/** Hoja de prueba registrada dinámicamente: lee su canal como una hoja real. */
-@Component({
-  standalone: true,
-  selector: 'app-hoja-prueba',
-  template: `<p data-hoja>{{ uiView }}</p>`,
-})
-class HojaPrueba {
-  readonly uiView: unknown;
-  constructor(route: ActivatedRoute) {
-    let valor: Record<string, unknown> = {};
-    route.data.subscribe((d) => (valor = d as Record<string, unknown>));
-    this.uiView = valor['uiView'];
-  }
-}
-
-const schema: ResourceSchema = {
-  id: 'demo',
-  label: 'Demo',
-  labelPlural: 'Demos',
-  kind: 'collection',
-  endpoint: {},
-  keyField: 'id',
-  titleField: 'name',
-  listColumns: [],
-  fields: [],
-  uiViews: { rows: { type: 'list' } },
-};
-
-describe('ViewSlot', () => {
-  afterEach(() => unregister('view', 'hoja-test'));
-
-  async function montar(node: ViewChildNode, profundidad = 0) {
-    const fixture = TestBed.createComponent(ViewSlot);
-    fixture.componentRef.setInput('schema', schema);
-    fixture.componentRef.setInput('node', node);
-    fixture.componentRef.setInput('parentInstanceId', 'panel');
-    fixture.componentRef.setInput('depth', profundidad);
-    fixture.detectChanges();
-    await fixture.whenStable();
-    fixture.detectChanges();
-    return fixture;
-  }
-
-  it('monta el hijo por descriptor del registro (load lazy) sin importar hojas', async () => {
-    register('view', {
-      kind: 'view',
-      type: 'hoja-test',
-      since: '9.9',
-      load: async () => HojaPrueba,
-    });
-    const fixture = await montar({ id: 'a', label: 'A', type: 'hoja-test' });
-    expect(fixture.nativeElement.querySelector('[data-hoja]')).toBeTruthy();
-    // uiView del payload = instanceId virtual (parentId + '/' + id)
-    expect(fixture.nativeElement.textContent).toContain('panel/a');
-  });
-
-  it('tipo sin descriptor ⇒ estado de error legible, sin fallback del registro', async () => {
-    const fixture = await montar({ id: 'x', label: 'X', type: 'no-existe' });
-    expect(fixture.nativeElement.textContent).toContain('descriptor');
-    expect(fixture.nativeElement.querySelector('[data-hoja]')).toBeFalsy();
-  });
-
-  it('load() rechaza ⇒ error explícito con el rechazo retenido para diagnóstico', async () => {
-    const rechazo = new Error('fallo de red');
-    register('view', {
-      kind: 'view',
-      type: 'hoja-test',
-      since: '9.9',
-      load: async () => {
-        throw rechazo;
-      },
-    });
-    const fixture = await montar({ id: 'a', label: 'A', type: 'hoja-test' });
-    expect(fixture.nativeElement.textContent).toContain('fallo de red');
-    expect(fixture.componentInstance.error()).toBe(rechazo);
-  });
-
-  it('ref resuelve la uiView del schema y el payload expone su config bajo instanceId', async () => {
-    register('view', {
-      kind: 'view',
-      type: 'hoja-test',
-      since: '9.9',
-      load: async () => HojaPrueba,
-    });
-    const schemaConRef: ResourceSchema = {
-      ...schema,
-      uiViews: { ...schema.uiViews, destino: { type: 'hoja-test' } },
-    };
-    const fixture = TestBed.createComponent(ViewSlot);
-    fixture.componentRef.setInput('schema', schemaConRef);
-    fixture.componentRef.setInput('node', { id: 'h', label: 'H', ref: 'destino' });
-    fixture.componentRef.setInput('parentInstanceId', 'panel');
-    fixture.detectChanges();
-    await fixture.whenStable();
-    fixture.detectChanges();
-    expect(fixture.nativeElement.textContent).toContain('panel/h');
-    expect(fixture.componentInstance.payload()?.['schema']).toBeDefined();
-  });
-
-  it('el payload lleva `select` declarado para que la hoja conozca el binding', async () => {
-    register('view', {
-      kind: 'view',
-      type: 'hoja-test',
-      since: '9.9',
-      load: async () => HojaPrueba,
-    });
-    const fixture = await montar({
-      id: 'a',
-      label: 'A',
-      type: 'hoja-test',
-      select: { on: 'open', mode: 'none' },
-    });
-    expect(fixture.componentInstance.payload()?.['select']).toEqual({ on: 'open', mode: 'none' });
-  });
-
-  it('profundidad sobre el límite ⇒ error antes de montar (guard del host)', async () => {
-    const fixture = await montar({ id: 'a', label: 'A', type: 'list' }, 4);
-    expect(fixture.nativeElement.textContent).toContain('profundidad');
-    expect(fixture.nativeElement.querySelector('[data-hoja]')).toBeFalsy();
-  });
-});

package/src/lib/views/composer/view-slot.ts

@@ -1,178 +0,0 @@
-import {
-  ChangeDetectionStrategy,
-  Component,
-  EnvironmentInjector,
-  Injector,
-  ViewContainerRef,
-  effect,
-  inject,
-  input,
-  signal,
-  viewChild,
-} from '@angular/core';
-import { ActivatedRoute } from '@angular/router';
-
-import type { ResourceSchema, ViewChildNode } from '../../core/models/schema.model';
-import { MAX_DEPTH } from '../../core/registry/composition-validator';
-import { get } from '../../core/registry/render-registry';
-import { ViewNavigationService } from '../../core/view-navigation/view-navigation.service';
-import { EmptyState } from '../../shared/components/empty-state/empty-state';
-import { createViewContext, instanceIdFor, syntheticRoute, virtualSchemaFor } from './view-context';
-import type { ViewContextData } from './view-context';
-
-/**
- * R9.9 · slice 3 — Slot de instancia embebida.
- *
- * Monta UN hijo de composición resolviéndolo SOLO por `(kind:'view', type)`
- * en el registro (`get`, nunca `resolve` ⇒ el fallback silencioso del
- * registro es inalcanzable, D2) y entregándole un canal ViewContext
- * sintético (D1). Cada slot es una isla: carga/error/estado se aíslan por
- * `instanceId`, y el rechazo de `load()` queda retenido en `error()` para
- * diagnóstico sin tumbar a los hermanos.
- */
-@Component({
-  selector: 'app-view-slot',
-  standalone: true,
-  imports: [EmptyState],
-  changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `
-    @if (status() === 'loading') {
-      <div role="status" class="p-3 text-sm text-neutral">Cargando…</div>
-    } @else if (status() === 'error') {
-      <app-empty-state title="No se pudo mostrar esta vista" [message]="mensaje()" />
-    } @else {
-      <div #host></div>
-    }
-  `,
-})
-export class ViewSlot {
-  /** Schema del recurso padre (el host le pasa el schema real). */
-  readonly schema = input.required<ResourceSchema>();
-  /** Nodo declarado (inline con `type` o por `ref`). */
-  readonly node = input.required<ViewChildNode>();
-  /** instanceId del contenedor padre (raíz ⇒ nombre de la uiView de ruta). */
-  readonly parentInstanceId = input.required<string>();
-  /** Profundidad del propio slot (hijo de raíz ⇒ 1). */
-  readonly depth = input(0);
-
-  /** Estado de ESTE slot — aislado por instancia, jamás compartido con hermanos. */
-  readonly status = signal<'loading' | 'ready' | 'error'>('loading');
-  /** Rechazo original retenido para diagnóstico (el display usa `mensaje()`). */
-  readonly error = signal<unknown>(null);
-  /** Payload entregado al hijo (público para tests/diagnóstico). */
-  readonly payload = signal<ViewContextData | null>(null);
-
-  private readonly nav = inject(ViewNavigationService);
-  private readonly envInjector = inject(EnvironmentInjector);
-  private readonly ancla = viewChild('host', { read: ViewContainerRef });
-
-  private epoch = 0;
-  private pendiente: { tipo: unknown; injector: Injector } | null = null;
-
-  constructor() {
-    // Fase 1: montaje/reactivo — cualquier cambio de inputs re-monta el slot.
-    effect(() => this.monar());
-    // Fase 2: cuando el ancla #host existe (status ready), crear el hijo.
-    effect(() => {
-      if (this.status() !== 'ready') return;
-      const pend = this.pendiente;
-      let ancla: ViewContainerRef | undefined;
-      try {
-        ancla = this.ancla();
-      } catch {
-        ancla = undefined; // ancla aún no materializada; el effect re-corre al aparecer
-      }
-      if (!pend || !ancla) return;
-      this.pendiente = null;
-      ancla.clear();
-      ancla.createComponent(pend.tipo as never, { injector: pend.injector });
-    });
-  }
-
-  private async monar(): Promise<void> {
-    const esquema = this.schema();
-    const nodo = this.node();
-    if (!esquema || !nodo) return;
-    const turno = ++this.epoch;
-    this.pendiente = null;
-
-    if (this.depth() > MAX_DEPTH) {
-      this.error.set(
-        new Error(
-          `Límite de profundidad de composición excedido (${MAX_DEPTH}) en ${esquema.id}.${nodo.id}`,
-        ),
-      );
-      this.status.set('error');
-      return;
-    }
-
-    // Referencia por uiView del mismo schema o nodo inline.
-    const resuelto = 'ref' in nodo ? esquema.uiViews?.[nodo.ref] : nodo;
-    if (resuelto === undefined) {
-      const ref = 'ref' in nodo ? nodo.ref : nodo.id;
-      this.error.set(new Error(`Referencia '${ref}' inexistente en ${esquema.id}`));
-      this.status.set('error');
-      return;
-    }
-
-    const descriptor = get('view', resuelto.type);
-    if (!descriptor) {
-      // Sin fallback: error legible, nunca pantalla de reserva (D2).
-      this.error.set(
-        new Error(`No existe descriptor kind:view type '${resuelto.type}' en ${esquema.id}`),
-      );
-      this.status.set('error');
-      return;
-    }
-
-    const instanceId = instanceIdFor(this.parentInstanceId(), nodo.id);
-    const select = 'ref' in nodo ? resuelto.select : nodo.select;
-    const virtual = virtualSchemaFor(esquema, instanceId, resuelto);
-    // D4: el emisor va a `dispatch` (target resuelto, segmentos, guards);
-    // sólo un binding `mode:'route'` lleva `emit`, pero el payload declara
-    // `select` SIEMPRE para que la hoja aplique la decision table.
-    const emit =
-      select?.mode === 'route'
-        ? (event: Parameters<NonNullable<ViewContextData['emit']>>[0]): void => {
-            void this.nav.dispatch(select, event);
-          }
-        : undefined;
-    this.payload.set(
-      createViewContext(
-        {
-          schema: virtual,
-          resourceId: esquema.id,
-          uiView: instanceId,
-          viewType: resuelto.type,
-          depth: this.depth(),
-          ...(select !== undefined ? { select } : {}),
-        },
-        emit,
-      ),
-    );
-
-    this.error.set(null);
-    this.status.set('loading');
-    const injector = Injector.create({
-      providers: [{ provide: ActivatedRoute, useValue: syntheticRoute(this.payload()!) }],
-      parent: this.envInjector,
-    });
-
-    try {
-      const tipo = await descriptor.load();
-      if (turno !== this.epoch) return; // inputs cambiaron: descartar
-      this.pendiente = { tipo, injector };
-      this.status.set('ready');
-    } catch (e) {
-      if (turno !== this.epoch) return;
-      this.error.set(e);
-      this.status.set('error');
-    }
-  }
-
-  /** Mensaje mostrado (el error original queda en `error()`). */
-  mensaje(): string {
-    const e = this.error();
-    return e instanceof Error ? e.message : String(e);
-  }
-}

package/src/lib/views/descriptors.ts

@@ -1,46 +0,0 @@
-import type { RenderDescriptor } from '../core/registry/render-registry';
-
-export const viewDescriptors: readonly RenderDescriptor[] = [
-  {
-    kind: 'view',
-    type: 'list',
-    since: '9.1',
-    load: async () => (await import('../pages/resource-page/resource-page')).ResourcePage,
-  },
-  {
-    kind: 'view',
-    type: 'detail',
-    since: '9.1',
-    load: async () => (await import('../pages/resource-page/resource-page')).ResourcePage,
-  },
-  {
-    kind: 'view',
-    type: 'form',
-    since: '9.1',
-    load: async () => (await import('../pages/form-view/form-view')).FormView,
-  },
-  {
-    kind: 'view',
-    type: 'dashboard',
-    since: '9.1',
-    load: async () => (await import('../pages/resource-page/resource-page')).ResourcePage,
-  },
-  {
-    kind: 'view',
-    type: 'calendar',
-    since: '9.8',
-    load: async () => (await import('./calendar-view/calendar-view')).CalendarView,
-  },
-  {
-    kind: 'view',
-    type: 'kanban',
-    since: '9.8',
-    load: async () => (await import('./kanban-view/kanban-view')).KanbanView,
-  },
-  {
-    kind: 'view',
-    type: 'tabs',
-    since: '9.9',
-    load: async () => (await import('./composer/composer-host')).ComposerHost,
-  },
-];