Los artículos anteriores de la serie sobre silverpoint enseñaron cada pieza por separado. Este las junta en una aplicación de Angular: Operations, el panel de operaciones del servicio web, con tres páginas.
Es la misma aplicación que los artículos 23 (React con Next.js), 24 (Vue) y 26 (Reflex). El 27 compara las cuatro. Aquí se construye con lo que Angular trae: el CLI, el router, componentes standalone y signals, sin librerías de estado.
Lo que vas a construir
| Ruta | Página | Lo que usa |
|---|---|---|
/ | Overview | Un panel con indicadores, visitas en vivo, errores enlazados por hora, mapa de calor y donut; la lectura de la hora activa; la descarga en SVG |
/incidents | Incidents | La tabla de incidencias ordenable y paginada, el modal para reconocer una y el aviso |
/settings | Settings | El formulario de la regla de alerta y el tema: paleta y estilo base |
Cada página reúne artículos anteriores:
| Pieza | Artículo |
|---|---|
| El proyecto de Angular | 05 |
| El proveedor y los estilos base | 09 |
| El elemento activo | 11 |
| Paletas y cambio de tema | 12 |
| El panel y el enlace por hora | 13 |
| El formulario | 16 |
| Tabla, modal y aviso | 17 |
| La exportación a SVG | 18 |
| Los datos en vivo | 20 |
Lo que necesitas
El proyecto de Angular del artículo 05, creado con el CLI de Angular 22 y con @silverpoint/angular, @silverpoint/grounds y @silverpoint/fonts 0.10.1. El router y los formularios reactivos vienen con el proyecto.
Añade el motor como dependencia propia:
npm install @silverpoint/core
Ya estaba instalado, porque lo trae el adaptador. Pero la aplicación importa de él las paletas, uiSortRows y algunos tipos, y lo que importas debe estar en tu package.json.
La estructura
ops-panel
├── angular.json
├── package.json
├── package-lock.json
├── public
│ └── favicon.ico
├── README.md
├── src
│ ├── app
│ │ ├── app.config.ts
│ │ ├── app.routes.ts
│ │ ├── app.ts
│ │ ├── data
│ │ │ ├── incidents.ts
│ │ │ └── ops.ts
│ │ ├── export-svg.ts
│ │ ├── incident-log.ts
│ │ ├── live-feed.ts
│ │ ├── pages
│ │ │ ├── alert-rule-form.ts
│ │ │ ├── incidents.ts
│ │ │ ├── overview.ts
│ │ │ └── settings-page.ts
│ │ └── settings.ts
│ ├── index.html
│ ├── main.ts
│ └── styles.css
├── tsconfig.app.json
├── tsconfig.json
└── tsconfig.spec.json
main.ts e index.html son los del CLI; en index.html solo cambia el título. Los datos de src/app/data/ son los de la serie: ops.ts, del artículo 13, y incidents.ts, del 17, sin cambios. El resto se explica a continuación.
1. Las rutas
src/app/app.routes.ts:
import { Routes } from '@angular/router';
export const routes: Routes = [
{
path: '',
title: 'Overview · Operations',
loadComponent: () => import('./pages/overview').then((m) => m.Overview),
},
{
path: 'incidents',
title: 'Incidents · Operations',
loadComponent: () => import('./pages/incidents').then((m) => m.Incidents),
},
{
path: 'settings',
title: 'Settings · Operations',
loadComponent: () => import('./pages/settings-page').then((m) => m.SettingsPage),
},
{ path: '**', redirectTo: '' },
];
Cada página se carga con loadComponent, así que el CLI la pone en su propio archivo y el navegador la descarga la primera vez que la visitas. title cambia el título de la pestaña. Cualquier otra ruta vuelve a Overview.
2. Los ajustes: un servicio con signals
El tema y la regla de alerta se usan en varias páginas. Viven en un servicio de toda la aplicación, src/app/settings.ts:
import { Injectable, computed, effect, signal } from '@angular/core';
import type { GroundName, Palette } from '@silverpoint/core';
import { indigo, ironGall, sanguine, sepia, silverpoint, verdigris } from '@silverpoint/core/palettes';
export const PALETTES: { key: string; label: string; palette: Palette }[] = [
{ key: 'silverpoint', label: 'Silverpoint', palette: silverpoint },
{ key: 'sanguine', label: 'Sanguine', palette: sanguine },
{ key: 'sepia', label: 'Sepia', palette: sepia },
{ key: 'iron-gall', label: 'Iron gall', palette: ironGall },
{ key: 'verdigris', label: 'Verdigris', palette: verdigris },
{ key: 'indigo', label: 'Indigo', palette: indigo },
];
export type AlertRule = {
metric: string;
threshold: number;
channel: string;
active: boolean;
notes: string;
};
type Stored = { paletteKey: string; cyanotype: boolean };
const KEY = 'operations-theme';
const DEFAULTS: Stored = { paletteKey: 'silverpoint', cyanotype: false };
// localStorage can be missing or blocked: the app then keeps the theme in memory.
function load(): Stored {
try {
return { ...DEFAULTS, ...JSON.parse(localStorage.getItem(KEY) ?? 'null') };
} catch {
return DEFAULTS;
}
}
@Injectable({ providedIn: 'root' })
export class Settings {
readonly paletteKey = signal(load().paletteKey);
readonly cyanotype = signal(load().cyanotype);
readonly rule = signal<AlertRule>({
metric: 'errors',
threshold: 10,
channel: 'email',
active: true,
notes: '',
});
readonly ground = computed<GroundName>(() => (this.cyanotype() ? 'cyanotype' : 'silverpoint'));
// Cyanotype prints with its own inks on Prussian blue: no palette on top.
readonly palette = computed(() =>
this.cyanotype() ? undefined : PALETTES.find((p) => p.key === this.paletteKey())?.palette,
);
constructor() {
effect(() => {
const stored: Stored = { paletteKey: this.paletteKey(), cyanotype: this.cyanotype() };
try {
localStorage.setItem(KEY, JSON.stringify(stored));
} catch {
// Not saved: the theme lasts until the page is reloaded.
}
});
}
}
Un servicio con providedIn: 'root' existe una vez y dura lo que dura la página. No hace falta una librería de estado: los signals ya avisan a quien los lee.
El tema se guarda en localStorage, dentro de try/catch. En una ventana privada o con el almacenamiento bloqueado, localStorage puede lanzar un error; entonces el tema dura hasta que recargues. La regla de alerta solo se guarda en memoria, para la sesión.
Con el estilo base cyanotype no se aplica paleta: la cianotipia imprime con sus propias tintas sobre azul de Prusia, y una paleta pensada para papel claro no se leería.
3. El proveedor que sigue al tema
El artículo 09 configuraba el estilo de toda la aplicación con provideSilverpoint. En Angular, esa función recibe un objeto fijo: no hay forma de cambiarle el estilo base después. Por eso el artículo 12 pasaba el tema a cada gráfico.
Aquí se usa otra vía. src/app/app.config.ts registra el mismo token que usa provideSilverpoint, SILVERPOINT_CONFIG, con un objeto cuyos campos leen los ajustes:
import { ApplicationConfig, inject, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideRouter } from '@angular/router';
import type { ProviderConfig } from '@silverpoint/core';
import { SILVERPOINT_CONFIG } from '@silverpoint/angular/env';
import { routes } from './app.routes';
import { Settings } from './settings';
export const appConfig: ApplicationConfig = {
providers: [
provideBrowserGlobalErrorListeners(),
provideRouter(routes),
{
// provideSilverpoint() takes a fixed object. This provider reads the
// settings on every render, so every chart and component follows them.
provide: SILVERPOINT_CONFIG,
useFactory: (): ProviderConfig => {
const settings = inject(Settings);
return {
get ground() {
return settings.ground();
},
get palette() {
return settings.palette();
},
};
},
},
],
};
Funciona porque los gráficos y los componentes de silverpoint leen el proveedor dentro de un computed. Al leer ground, el getter lee settings.ground(), y Angular anota esa dependencia. Cuando cambias el tema, cada gráfico y cada componente se vuelve a dibujar con el nuevo.
Lo comprobé quitando todas las demás vías: sin pasar el tema a ningún gráfico, los seis gráficos, el marco del panel, la tabla, los botones y los controles cambian de paleta y de estilo base. Es un uso del token que la documentación no describe, así que compruébalo si actualizas silverpoint.
SILVERPOINT_CONFIG se importa de @silverpoint/angular/env. Desde @silverpoint/angular también existe, pero arrastra unos 42 kB más al paquete inicial, y el CLI avisa de que se pasa del presupuesto de 500 kB.
4. El marco de la aplicación
src/app/app.ts es el componente raíz: la barra de navegación, el router-outlet y los colores de la página.
import { Component, computed, inject } from '@angular/core';
import { RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import { paletteStyle } from '@silverpoint/core/palettes';
import { Settings } from './settings';
@Component({
selector: 'app-root',
imports: [RouterLink, RouterLinkActive, RouterOutlet],
template: `
<div class="shell" [class]="'sp-ground-' + settings.ground()" data-substrate="cream" [style]="inks()">
<header>
<strong>Operations</strong>
<nav aria-label="Main">
<a routerLink="/" routerLinkActive="current" [routerLinkActiveOptions]="{ exact: true }" ariaCurrentWhenActive="page">Overview</a>
<a routerLink="/incidents" routerLinkActive="current" ariaCurrentWhenActive="page">Incidents</a>
<a routerLink="/settings" routerLinkActive="current" ariaCurrentWhenActive="page">Settings</a>
</nav>
</header>
<main>
<router-outlet />
</main>
</div>
`,
styles: `
.shell {
min-height: 100vh;
background: var(--sp-substrate);
color: var(--sp-text);
font-family: var(--sp-font-display);
}
header {
display: flex;
gap: 32px;
align-items: baseline;
padding: 16px 32px;
border-bottom: 1px solid var(--sp-rule);
}
nav {
display: flex;
gap: 20px;
}
a {
color: var(--sp-text-muted);
text-decoration: none;
}
a.current {
color: var(--sp-text);
text-decoration: underline;
}
main {
max-width: 1200px;
padding: 24px 32px;
}
`,
})
export class App {
protected readonly settings = inject(Settings);
// The palette as --sp-* properties, so the page itself takes its colours.
protected readonly inks = computed(() => paletteStyle(this.settings.palette()));
}
Los gráficos ya siguen al tema, pero el fondo de la página no es de silverpoint. Para que también cambie, el marco lleva la clase del estilo base, sp-ground-silverpoint o sp-ground-cyanotype, y data-substrate="cream". Con ellas, la hoja de estilos de silverpoint le da las variables --sp-* del estilo base. paletteStyle añade las de la paleta, y el CSS del marco usa var(--sp-substrate) y var(--sp-text).
routerLinkActive marca el enlace de la página actual, y ariaCurrentWhenActive le añade aria-current="page" para los lectores de pantalla. Overview necesita exact: true; si no, / estaría activo en todas las páginas.
5. Los datos en vivo
El artículo 20 movía una ventana de 24 horas cada 2 segundos. Aquí avanzan a la vez las visitas y los errores, porque las dos gráficas los comparten. src/app/live-feed.ts:
import { Injectable, computed, signal } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { interval } from 'rxjs';
import { hourly, type HourRow } from './data/ops';
// The next reading: the hour after the last one, taken from the day's
// profile with a small variation that changes from tick to tick.
export function nextReading(last: HourRow, tick: number): HourRow {
const hour = (Number(last.hour) + 1) % 24;
return {
hour: String(hour).padStart(2, '0'),
hits: hourly[hour].hits + ((tick * 7) % 9) - 4,
errors: Math.max(0, hourly[hour].errors + ((tick * 5) % 3) - 1),
};
}
// A rolling window: drop the oldest hour and append the new one.
export function advance(rows: readonly HourRow[], tick: number): HourRow[] {
return [...rows.slice(1), nextReading(rows[rows.length - 1], tick)];
}
const sum = (rows: readonly HourRow[], key: 'hits' | 'errors') =>
rows.reduce((total, row) => total + row[key], 0);
// One feed for the whole app: it keeps running while you visit other pages.
@Injectable({ providedIn: 'root' })
export class LiveFeed {
readonly rows = signal(hourly);
readonly hits = computed(() => sum(this.rows(), 'hits'));
readonly errors = computed(() => sum(this.rows(), 'errors'));
constructor() {
interval(2000)
.pipe(takeUntilDestroyed())
.subscribe((tick) => this.rows.update((current) => advance(current, tick + 1)));
}
}
El intervalo está en un servicio de toda la aplicación, no en la página. Si vas a Incidents y vuelves, la ventana sigue donde iba. takeUntilDestroyed lo detiene si la aplicación se destruye.
hits y errors son los totales de la ventana: los indicadores de la página los muestran y cambian con cada lectura.
6. La página Overview
src/app/pages/overview.ts:
import { Component, computed, inject, signal, viewChild } from '@angular/core';
import type { ActiveItem } from '@silverpoint/core';
import { SpBarChart } from '@silverpoint/angular/bar-chart';
import { SpDashboard, SpDashboardCell, type DashboardLayout } from '@silverpoint/angular/dashboard';
import { SpDonutChart } from '@silverpoint/angular/donut-chart';
import { SpHeatmapChart } from '@silverpoint/angular/heatmap-chart';
import { SpKpiCard } from '@silverpoint/angular/kpi-card';
import { SpLineChart } from '@silverpoint/angular/line-chart';
import { SpButton } from '@silverpoint/angular/ui/button';
import { blocks, errorsByDay, sales } from '../data/ops';
import { downloadSvg } from '../export-svg';
import { LiveFeed } from '../live-feed';
@Component({
selector: 'app-overview',
imports: [SpBarChart, SpButton, SpDashboard, SpDashboardCell, SpDonutChart, SpHeatmapChart, SpKpiCard, SpLineChart],
template: `
<sp-dashboard
id="ops"
title="Overview"
description="Traffic, errors and sales of the web service, updated every 2 seconds."
[layout]="layout"
[link]="{ key: 'hour' }"
>
<sp-dashboard-cell cell="hits-today">
<sp-kpi-card title="Hits today" [data]="feed.rows()" valueKey="hits" [value]="feed.hits()" unit="thousand hits" />
</sp-dashboard-cell>
<sp-dashboard-cell cell="errors-today">
<sp-kpi-card title="Errors today" [data]="feed.rows()" valueKey="errors" [value]="feed.errors()" unit="errors" />
</sp-dashboard-cell>
<sp-dashboard-cell cell="traffic">
<sp-line-chart
#hits
title="Hits per hour"
badge="Live"
[data]="feed.rows()"
xKey="hour"
valueKey="hits"
footerLeft="Thousands, last 24 hours"
(activeChange)="active.set($event)"
/>
</sp-dashboard-cell>
<sp-dashboard-cell cell="errors-hour">
<sp-bar-chart title="Errors per hour" [data]="feed.rows()" xKey="hour" valueKey="errors" />
</sp-dashboard-cell>
<sp-dashboard-cell cell="errors-day">
<sp-heatmap-chart
title="Errors by day"
[data]="errorsByDay"
labelKey="day"
valuesKey="values"
[columnLabels]="blocks"
[scaleMax]="40"
/>
</sp-dashboard-cell>
<sp-dashboard-cell cell="channels">
<sp-donut-chart title="Sales by channel" [data]="sales" nameKey="channel" valueKey="sales" centerLabel="thousand EUR" />
</sp-dashboard-cell>
</sp-dashboard>
<div class="actions">
<p aria-live="polite">{{ readout() }}</p>
<button type="button" spButton (click)="download()">Download SVG</button>
</div>
`,
styles: `
.actions {
display: flex;
gap: 16px;
align-items: center;
justify-content: space-between;
padding: 0 16px;
}
`,
})
export class Overview {
protected readonly feed = inject(LiveFeed);
protected readonly errorsByDay = errorsByDay;
protected readonly blocks = blocks;
protected readonly sales = sales;
protected readonly layout: DashboardLayout = {
columns: { sm: 1, md: 2, lg: 4 },
rowHeight: 240,
gap: 16,
cells: [
{ id: 'hits-today' },
{ id: 'errors-today' },
{ id: 'traffic', colSpan: { md: 2, lg: 2 } },
{ id: 'errors-hour', colSpan: { md: 2, lg: 2 } },
{ id: 'errors-day' },
{ id: 'channels' },
],
};
protected readonly active = signal<ActiveItem | null>(null);
protected readonly readout = computed(() => {
const item = this.active();
if (!item) return 'Point at the hits chart to read an hour.';
const { hour, hits, errors } = item.datum;
return `${hour}:00 · ${hits} thousand hits · ${errors} errors`;
});
private readonly hits = viewChild.required<SpLineChart>('hits');
protected download() {
downloadSvg(this.hits().toSVGString(), 'hits-per-hour.svg');
}
}
Lo que hay que saber de cada parte:
- El panel es el del artículo 13, con la misma rejilla.
[link]="{ key: 'hour' }"enlaza los gráficos por la hora: al pasar por una hora de las visitas, se marca la misma hora en los errores y en los indicadores. - El tema del panel. Desde silverpoint 0.10.0, el marco del panel sigue al proveedor, igual que sus gráficos: su fondo y sus bordes cambian con el tema sin poner
[ground]ni[palette]ensp-dashboard(silverpoint#17). En la 0.9 se quedaban con la paleta de silverpoint. - La lectura usa
(activeChange)del gráfico de visitas, como en el artículo 11.item.datumes la fila completa. La desestructuración,const { hour, hits, errors } = item.datum, es válida connoPropertyAccessFromIndexSignature; conitem.datum.hour, la compilación fallaría. - La descarga.
viewChild.requiredencuentra el gráfico marcado con#hitsaunque esté dentro de una celda del panel, ytoSVGString()devuelve su SVG.
Los gráficos no llevan id: dentro de un panel, cada celda les da uno estable, como ops--traffic, y el trazo a mano no cambia entre lecturas.
7. La exportación a SVG
src/app/export-svg.ts es la función de descarga del artículo 18:
import { standaloneSVG } from '@silverpoint/grounds';
import groundCss from '@silverpoint/grounds/styles-text';
export function downloadSvg(svg: string, filename: string) {
// The SVG with the ground's stylesheet inside, so it looks the same outside the app.
const file = new Blob([standaloneSVG(svg, groundCss)], { type: 'image/svg+xml' });
const url = URL.createObjectURL(file);
const link = document.createElement('a');
link.href = url;
link.download = filename;
link.click();
URL.revokeObjectURL(url);
}
standaloneSVG mete en el SVG la hoja de estilos del estilo base, entre <![CDATA[ y ]]>, para que se vea igual fuera de la aplicación (silverpoint#14). La hoja llega como texto desde @silverpoint/grounds/styles-text, un módulo de JavaScript normal: no hace falta ninguna declaración de TypeScript ni tocar angular.json, y funciona igual con ng serve y con ng build (silverpoint#19).
Hasta la 0.9.2 había que importar styles.css con loader: 'text', y con ng serve eso dejaba la página en blanco salvo que se desactivara el preempaquetado con "prebundle": false.
8. La página Incidents
La tabla, el modal y el aviso son los del artículo 17. Solo cambia dónde viven las incidencias. src/app/incident-log.ts:
import { Injectable, computed, signal } from '@angular/core';
import { INCIDENTS } from './data/incidents';
// The incidents live here, not in the page, so an acknowledgement
// survives a visit to another page.
@Injectable({ providedIn: 'root' })
export class IncidentLog {
readonly rows = signal(INCIDENTS);
readonly openIds = computed(() => this.rows().filter((row) => row.status === 'open').map((row) => row.id));
acknowledge(id: string) {
this.rows.update((rows) => rows.map((row) => (row.id === id ? { ...row, status: 'acknowledged' } : row)));
}
}
Si reconoces una incidencia y cambias de página, sigue reconocida al volver. La plantilla de src/app/pages/incidents.ts es la del artículo 17, con log.rows() y log.openIds() en lugar de los signals locales, y un h1. La clase:
export class Incidents {
protected readonly log = inject(IncidentLog);
protected readonly columns = COLUMNS;
protected readonly pageSize = PAGE_SIZE;
protected readonly sortKey = signal('opened');
protected readonly sortOrder = signal<'asc' | 'desc'>('desc');
protected readonly page = signal(1);
protected readonly open = signal(false);
protected readonly picked = signal<string | null>(null);
protected readonly acknowledged = signal('');
protected readonly toastOpen = signal(false);
protected readonly visible = computed(() =>
uiSortRows(this.log.rows(), this.sortKey(), this.sortOrder()).slice(
(this.page() - 1) * PAGE_SIZE,
this.page() * PAGE_SIZE,
),
);
protected sort(key: string) {
this.sortOrder.set(key === this.sortKey() && this.sortOrder() === 'asc' ? 'desc' : 'asc');
this.sortKey.set(key);
this.page.set(1);
}
protected acknowledge() {
const picked = this.picked();
if (!picked) return;
this.log.acknowledge(picked);
this.acknowledged.set(picked);
this.picked.set(null);
this.open.set(false);
this.toastOpen.set(true);
}
}
El botón que abre el modal usa var(--sp-rule) y var(--sp-text) en sus estilos, así que también cambia con el tema.
9. La página Settings
src/app/pages/settings-page.ts:
import { Component, inject } from '@angular/core';
import { SpSelect } from '@silverpoint/angular/ui/select';
import { SpSwitch } from '@silverpoint/angular/ui/switch';
import { PALETTES, Settings } from '../settings';
import { AlertRuleForm } from './alert-rule-form';
@Component({
selector: 'app-settings-page',
imports: [AlertRuleForm, SpSelect, SpSwitch],
template: `
<h1>Settings</h1>
<div class="columns">
<section aria-labelledby="theme-title">
<h2 id="theme-title">Theme</h2>
<sp-select
label="Palette"
[items]="palettes"
[value]="settings.paletteKey()"
(valueChange)="settings.paletteKey.set($event ?? 'silverpoint')"
[disabled]="settings.cyanotype()"
/>
<sp-switch
label="Cyanotype ground"
[value]="settings.cyanotype()"
(valueChange)="settings.cyanotype.set(!!$event)"
/>
<p>The theme applies to every page and is kept on this device.</p>
</section>
<section aria-labelledby="alert-title">
<h2 id="alert-title">Alert rule</h2>
<app-alert-rule-form />
</section>
</div>
`,
styles: `
.columns {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
gap: 48px;
}
section {
display: grid;
gap: 16px;
align-content: start;
justify-items: start;
}
h2 {
margin: 0;
}
`,
})
export class SettingsPage {
protected readonly settings = inject(Settings);
protected readonly palettes = PALETTES.map(({ key, label }) => ({ key, label }));
}
sp-select y sp-switch reciben su valor con [value] y avisan con (valueChange). No uso [(value)] porque sus modelos admiten null o undefined, y los signals de los ajustes no: $event ?? 'silverpoint' y !!$event hacen la conversión. Con cyanotype, el selector de paleta se desactiva.
El formulario es el del artículo 16, con la misma plantilla. Cambia la clase de src/app/pages/alert-rule-form.ts, que ahora empieza desde la regla guardada y la guarda en los ajustes:
export class AlertRuleForm {
private readonly settings = inject(Settings);
protected readonly metrics = METRICS;
protected readonly channels = CHANNELS;
// The form starts from the saved rule, so it survives a visit to another page.
private readonly rule = this.settings.rule();
protected readonly form = new FormGroup({
metric: new FormControl(this.rule.metric, { nonNullable: true }),
threshold: new FormControl(this.rule.threshold, { nonNullable: true }),
channel: new FormControl(this.rule.channel, { nonNullable: true }),
active: new FormControl(this.rule.active, { nonNullable: true }),
notes: new FormControl(this.rule.notes, { nonNullable: true }),
});
protected readonly saved = computed(() => {
const { metric, threshold, channel, active, notes } = this.settings.rule();
return `Rule: ${metric} ≥ ${threshold}, by ${channel}, ${active ? 'active' : 'paused'}. Notes: ${notes || '—'}`;
});
protected save() {
this.settings.rule.set(this.form.getRawValue());
}
}
10. Los estilos globales
src/styles.css:
@import '@silverpoint/fonts/fonts.css';
@import '@silverpoint/grounds/styles.css';
@import '@silverpoint/grounds/ui.css';
body {
margin: 0;
}
Las fuentes, la hoja de estilos de los gráficos y la de los componentes. El resto de los estilos va en cada componente.
Ejecutar, compilar y desplegar
En desarrollo:
npx ng serve
La aplicación queda en http://localhost:4200. Para producción:
npx ng build
El resultado es una carpeta de archivos estáticos, dist/ops-panel/browser. En mi máquina, la compilación limpia tardó unos 4 segundos y produjo esto:
| Archivo | Tamaño | Comprimido (gzip) |
|---|---|---|
main (Angular, router, marco, ajustes) | 345,6 kB | 109,2 kB |
| Página Overview | 69,3 kB | 21,3 kB |
| Dos trozos compartidos de silverpoint | 81,5 kB | 23,3 kB |
| Página Incidents | 12,6 kB | 4,2 kB |
| Página Settings | 10,2 kB | 2,8 kB |
| CSS | 152,7 kB | 14,7 kB |
La primera visita a / descarga unos 157 kB comprimidos de JavaScript y CSS, más las tres fuentes. Las páginas Incidents y Settings llegan cuando las visitas.
Para desplegar, sube dist/ops-panel/browser a cualquier alojamiento estático. Hay una condición: el router de Angular navega en el navegador, pero si alguien recarga /incidents, el servidor recibe esa ruta y no tiene ese archivo. El alojamiento debe responder con index.html a las rutas que no existen. Vercel, Netlify, Cloudflare Pages y nginx lo permiten con una regla de reescritura. Para las pruebas usé un servidor estático de Node con esa regla.
Las comprobaciones
Probé la aplicación en Chrome con Playwright, 38 comprobaciones, con ng serve y con la compilación de producción. Pasaron todas en los dos:
| Página | Lo comprobado |
|---|---|
| Overview | Los seis gráficos llegan a data-status="ready"; la ventana avanza cada 2 segundos y mantiene 24 filas; el indicador cambia con ella; la lectura muestra la hora activa y se borra al salir; al pasar por las visitas se marcan los errores; el SVG descargado lleva la hoja de estilos |
| Navegación | Los enlaces cambian de página sin recargar; el enlace actual lleva aria-current; cada página tiene su título |
| Incidents | Cinco filas, las más recientes primero; orden por minutos en los dos sentidos; la página 3 tiene las dos últimas; el modal lista las cinco abiertas; el aviso nombra la incidencia; sigue reconocida al volver |
| Settings | El formulario guarda la regla; SMS está desactivado |
| Tema | Sanguina cambia el fondo de la página, los componentes, los seis gráficos y el marco del panel; la cianotipia cambia la página, los gráficos, la tabla y los botones; el tema sigue tras recargar |
Con silverpoint 0.10.1 repetí las comprobaciones principales, en desarrollo y en producción, y volvieron a pasar.
Además, sin errores en la consola. El primer gráfico estuvo listo a los 235 ms de empezar a cargar la página, y los seis a los 279 ms (la mediana de tres cargas de la compilación de producción, en mi máquina).
Angular 22 crea los proyectos sin zone.js: la pantalla se actualiza en el siguiente fotograma, no dentro del clic. Una prueba que lee la página justo después de hacer clic ve el estado anterior. Mi primera ejecución falló cinco comprobaciones por eso; una espera corta después de cada acción lo resolvió.
Problemas comunes
- Con
ng serve, la página queda en blanco y la consola habla de «export named 'default'». Se importóstyles.cssconloader: 'text'. Importa la hoja de@silverpoint/grounds/styles-text, que existe desde la 0.10.0 (silverpoint#19). - El tema cambia la página, pero no los gráficos. Se usó
provideSilverpointcon un objeto fijo. RegistraSILVERPOINT_CONFIGcon getters, como enapp.config.ts. - Los gráficos cambian, pero el marco del panel no. Tienes una versión anterior a la 0.10.0 (silverpoint#17). Actualiza los paquetes de silverpoint.
- El CLI avisa de que el paquete inicial pasa de 500 kB.
SILVERPOINT_CONFIGse importó de@silverpoint/angular. Impórtalo de@silverpoint/angular/env. - Al dejar el puntero sobre un gráfico, aparece también la descripción emergente del navegador. Hasta la 0.9.2,
title="Hits per hour"quedaba además como atributotitledesp-line-chart; la 0.10.0 ya no lo deja en el elemento (silverpoint#18). En Chrome la descripción sigue saliendo, porque viene del elemento<title>del SVG, que es el nombre accesible del gráfico. Escribirlo como[title]="'Hits per hour'"no la quita. - Al recargar
/settingsen producción, el servidor responde 404. Falta la regla que devuelveindex.html.
Lo que viene
Operations ya funciona en Angular. El artículo 26 construye la misma aplicación en Reflex, en Python, y le da datos reales: la latencia medida de servicios públicos.