El nivel 4 de la serie sobre silverpoint junta todo en un proyecto final. Los niveles anteriores construyeron el panel de operaciones pieza a pieza: el panel en rejilla, los componentes de interfaz, la exportación, el render en servidor y los datos en vivo. Este artículo los reúne en una aplicación de React con Next.js y su App Router, con tres páginas y un tema común.

Los artículos 24, 25 y 26 construyen la misma aplicación en Vue, Angular y Reflex, y el 27 las compara. Por eso las tres páginas son iguales en los cuatro.

La vista general del panel de operaciones en Next.js: los indicadores, el tráfico por hora en vivo con el puntero en las 11, los errores por hora enlazados, los errores por día y las ventas por canal

Lo que vas a construir

RutaPáginaViene de
/La vista general: indicadores, tráfico en vivo, errores enlazados por hora, errores por día, ventas por canal, una lectura de la hora activa y un botón de descarga en SVGArtículos 11, 13, 18 y 20
/incidentsLa tabla de incidencias ordenable y paginada, con la ventana para reconocer una incidencia y el avisoArtículo 17
/settingsEl tema, un estilo base y una paleta que cambian toda la aplicación, y el formulario de la regla de alertaArtículos 09, 12 y 16

Una barra de navegación con tres enlaces las une. Los ajustes se conservan mientras dura la sesión: al ir y volver entre páginas, el tema y la regla guardada siguen ahí. Al recargar la página vuelven a los valores por defecto.

Lo que necesitas

  • Node.js 20.9 o superior, el mínimo de Next.js 16. Lo probé con Node.js 24.
  • Next.js 16.4.6, React 19.3.0 y silverpoint 0.10.1.

El proyecto

Crea la aplicación e instala silverpoint:

npx create-next-app@latest ops-panel --ts --app --no-tailwind --no-eslint --no-src-dir --no-react-compiler --import-alias "@/*" --use-npm --yes
cd ops-panel
npm install @silverpoint/react @silverpoint/core @silverpoint/grounds @silverpoint/fonts

@silverpoint/core va aparte porque el código importa de él las paletas y el tipo ActiveItem, como en el artículo 12. Borra app/page.module.css y las imágenes de public/, que la plantilla trae de ejemplo. Al terminar, el proyecto tiene esta forma:

ops-panel/
├── app/
│   ├── layout.tsx                server: stylesheets, title, navigation
│   ├── globals.css
│   ├── settings-provider.tsx     client: settings and SilverpointProvider
│   ├── page.tsx                  server: the / route
│   ├── overview.tsx              client: the dashboard
│   ├── incidents/
│   │   ├── page.tsx              server: the /incidents route
│   │   └── incidents.tsx         client: table, modal and toast
│   └── settings/
│       ├── page.tsx              server: the /settings route
│       ├── theme-form.tsx        client: ground and palette
│       └── alert-rule-form.tsx   client: the alert rule
├── lib/
│   ├── ops.ts                    the panel's data
│   ├── live.ts                   the rolling window
│   ├── incidents.ts              the 12 incidents
│   ├── rule.ts                   the alert rule
│   └── download.ts               the SVG download
├── next.config.ts
├── package.json
└── tsconfig.json

Tres archivos de lib/ vienen sin cambios de artículos anteriores: lib/ops.ts es el del artículo 13, con las filas por hora, los errores por día y las ventas por canal; lib/incidents.ts es el del artículo 17, y lib/download.ts, el del artículo 18.

Servidor o cliente

En el App Router, cada archivo es un componente de servidor salvo que empiece por 'use client'. Un componente de servidor no envía JavaScript al navegador, pero tampoco puede tener estado, efectos, eventos ni leer un contexto de React.

ArchivoDóndePor qué
app/layout.tsxServidorLas hojas de estilos, el título y la navegación no cambian
app/page.tsx, app/incidents/page.tsx, app/settings/page.tsxServidorEl título de cada página y los encabezados
app/settings-provider.tsxClienteGuarda los ajustes en estado y los reparte con un contexto
app/overview.tsxClienteEl intervalo de los datos en vivo, la lectura, la descarga y el tema
app/incidents/incidents.tsxClienteEl orden, la página, la ventana y el aviso son estado
app/settings/theme-form.tsx, app/settings/alert-rule-form.tsxClienteSon formularios

El artículo 19 dibujaba los gráficos con las entradas de servidor, @silverpoint/react/server/.... Aquí no sirven: el tema vive en el estado del cliente y llega por el contexto de SilverpointProvider, que un componente de servidor no puede leer. Un gráfico de servidor se quedaría con el tema por defecto al cambiarlo en /settings. Por eso todos los gráficos son componentes de cliente.

Eso no los deja fuera del HTML. Next.js también renderiza los componentes de cliente al compilar, y dentro de un Dashboard cada gráfico recibe el tamaño de su celda. El artículo 19 contaba que un gráfico de cliente sin width llega al HTML como un hueco con data-status="deferred". Dentro del panel no pasa: el HTML de / trae los seis gráficos dibujados, con data-status="ready", antes de que cargue una línea de JavaScript.

La configuración

next.config.ts es el de la plantilla de create-next-app, sin cambios:

import type { NextConfig } from 'next';

const nextConfig: NextConfig = {
  cacheComponents: true,
  partialPrefetching: true,
};

export default nextConfig;

La descarga en SVG del artículo 18 no necesita nada aquí. standaloneSVG recibe la hoja de estilos del estilo base desde @silverpoint/grounds/styles-text, un módulo de JavaScript que Turbopack importa sin ninguna regla.

Hasta la 0.9.2 había que importar styles.css como texto con ?raw, y en Turbopack eso pedía una regla en turbopack.rules, una ruta relativa a node_modules y una declaración de tipos. La 0.10.0 lo hizo innecesario (issue #14).

El diseño común

app/layout.tsx es el único sitio donde se cargan las hojas de estilos: las fuentes, el estilo base y la de los componentes de interfaz del artículo 16. Envuelve todas las páginas con los ajustes y pone la navegación:

import type { Metadata } from 'next';
import Link from 'next/link';
import '@silverpoint/fonts/fonts.css';
import '@silverpoint/grounds/styles.css';
import '@silverpoint/grounds/ui.css';
import './globals.css';
import { SettingsProvider } from './settings-provider';

export const metadata: Metadata = {
  title: { default: 'Operations', template: '%s · Operations' },
  description: 'Traffic, errors, incidents and alert rules of the web service.',
};

export default function RootLayout({ children }: LayoutProps<'/'>) {
  return (
    <html lang="en">
      <body>
        <SettingsProvider>
          <nav aria-label="Main">
            <Link href="/">Overview</Link>
            <Link href="/incidents">Incidents</Link>
            <Link href="/settings">Settings</Link>
          </nav>
          <main>{children}</main>
        </SettingsProvider>
      </body>
    </html>
  );
}

LayoutProps<'/'> es un tipo global que Next.js genera a partir de las rutas. title.template hace que el título de /incidents sea «Incidents · Operations».

La navegación y main son componentes de servidor, pero van dentro de SettingsProvider, que es de cliente. Next.js lo permite: un componente de cliente puede recibir componentes de servidor como children. Lo que no se puede es importar un componente de servidor desde uno de cliente.

Link navega sin recargar la página. El diseño no se vuelve a montar al cambiar de ruta, así que el estado de SettingsProvider se conserva.

El tema y los ajustes

app/settings-provider.tsx guarda los ajustes en estado: el estilo base, la paleta y la regla de alerta. Los reparte con un contexto y pasa el tema a SilverpointProvider:

'use client';

import { createContext, useContext, useState, type CSSProperties, type ReactNode } from 'react';
import type { GroundName, Palette } from '@silverpoint/core';
import { PALETTES, paletteStyle, type PaletteName } from '@silverpoint/core/palettes';
import { SilverpointProvider } from '@silverpoint/react/provider';
import { DEFAULT_RULE, type AlertRule } from '@/lib/rule';

export type Settings = {
  ground: GroundName;
  palette: PaletteName;
  rule: AlertRule;
};

type SettingsContextValue = {
  settings: Settings;
  palette: Palette | undefined;
  update: (change: Partial<Settings>) => void;
};

const SettingsContext = createContext<SettingsContextValue | null>(null);

export function useSettings(): SettingsContextValue {
  const value = useContext(SettingsContext);
  if (!value) throw new Error('useSettings() needs a <SettingsProvider> above it');
  return value;
}

// The palette's --sp-* declarations as a React style object, so the page
// itself is painted with the same substrate and text colours as the charts.
function paletteVars(palette: Palette | undefined): CSSProperties {
  const pairs = paletteStyle(palette)
    .split(';')
    .filter(Boolean)
    .map((declaration) => declaration.split(':'));
  return Object.fromEntries(pairs);
}

export function SettingsProvider({ children }: { children: ReactNode }) {
  const [settings, setSettings] = useState<Settings>({
    ground: 'silverpoint',
    palette: 'silverpoint',
    rule: DEFAULT_RULE,
  });

  const update = (change: Partial<Settings>) => setSettings((current) => ({ ...current, ...change }));
  // Cyanotype brings its own colours; a palette only applies to silverpoint.
  const palette = settings.ground === 'silverpoint' ? PALETTES[settings.palette] : undefined;

  return (
    <SettingsContext value={{ settings, palette, update }}>
      <SilverpointProvider ground={settings.ground} palette={palette}>
        <div className={`shell sp-ground-${settings.ground}`} data-substrate="cream" style={paletteVars(palette)}>
          {children}
        </div>
      </SilverpointProvider>
    </SettingsContext>
  );
}

Tres decisiones de este archivo:

  • La cianotipia no lleva paleta. Trae sus propios colores, como contaba el artículo 12. Con ground="cyanotype", palette es undefined, y en /settings el selector de paleta se desactiva.
  • La página también cambia de color. SilverpointProvider no dibuja ningún elemento: solo reparte la configuración a los gráficos y componentes que tiene debajo. Para que el fondo de la página acompañe al tema, el div que envuelve la aplicación lleva la clase del estilo base, sp-ground-silverpoint o sp-ground-cyanotype, y las propiedades --sp-* de la paleta. paletteStyle devuelve esas declaraciones como texto; paletteVars las convierte en un objeto de estilo de React. Con eso, background: var(--sp-substrate) en globals.css pinta la página con el sustrato del tema.
  • El contexto también da la paleta resuelta. El panel de la vista general la necesita, como se ve más abajo.

Las hojas del estilo base declaran sus propiedades dentro de :where(), sin peso, precisamente para que una regla tuya pueda cambiarlas. Por eso la clase del estilo base sirve también en un elemento que no es un gráfico.

Los estilos

app/globals.css completo:

body {
  margin: 0;
}

.shell {
  min-height: 100vh;
  padding: 24px 32px;
  background: var(--sp-substrate);
  color: var(--sp-text);
  font-family: var(--sp-font-display);
}

nav {
  display: flex;
  gap: 24px;
  margin-bottom: 24px;
  font-size: 18px;
}

nav a {
  color: inherit;
}

h1 {
  margin: 0 0 16px;
  font-weight: 500;
}

.toolbar {
  display: flex;
  gap: 16px;
  align-items: center;
  margin-top: 16px;
}

.stack {
  display: grid;
  gap: 16px;
  align-content: start;
  justify-items: start;
  max-width: 720px;
}

.sp-table {
  justify-self: stretch;
}

button[aria-haspopup='dialog'] {
  padding: 6px 14px;
  border: 1px solid currentColor;
  border-radius: 2px;
  background: transparent;
  color: inherit;
  font: inherit;
  cursor: pointer;
}

form {
  display: grid;
  gap: 20px;
  align-content: start;
}

.settings {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
  gap: 48px;
}

h2 {
  margin: 0;
  font-weight: 500;
}

.stack es una columna para el contenido de las incidencias y de cada bloque de ajustes. Al principio era una regla sobre section, como en el artículo 17, pero Dashboard también es una section: con max-width: 720px el panel pasaba de cuatro columnas a dos.

Los datos en vivo y la regla de alerta

lib/live.ts es la ventana que avanza del artículo 20, ahora sobre las filas del panel. Cada lectura nueva copia la fila de esa hora, con sus errores, y cambia las visitas:

import { hourly, type HourRow } from './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 { ...hourly[hour], hits: hourly[hour].hits + ((tick * 7) % 9) - 4 };
}

// 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)];
}

lib/rule.ts describe la regla de alerta del artículo 16. Antes era el estado del formulario; ahora es un ajuste más, para que la regla guardada siga ahí al volver a /settings:

export type AlertRule = {
  metric: string;
  threshold: number;
  channel: string;
  active: boolean;
  notes: string;
};

export const DEFAULT_RULE: AlertRule = {
  metric: 'errors',
  threshold: 10,
  channel: 'email',
  active: true,
  notes: '',
};

export function describeRule(rule: AlertRule): string {
  const state = rule.active ? 'active' : 'paused';
  return `${rule.metric} ≥ ${rule.threshold}, by ${rule.channel}, ${state}. Notes: ${rule.notes || '—'}`;
}

La vista general

app/page.tsx es un componente de servidor que solo pone el panel:

import { Overview } from './overview';

export default function OverviewPage() {
  return <Overview />;
}

Y app/overview.tsx, el panel del artículo 13 con los datos en vivo, la lectura y la descarga:

'use client';

import { useEffect, useRef, useState } from 'react';
import type { ActiveItem } from '@silverpoint/core';
import { BarChart } from '@silverpoint/react/bar-chart';
import { Dashboard, DashboardCell, type DashboardLayout } from '@silverpoint/react/dashboard';
import { DonutChart } from '@silverpoint/react/donut-chart';
import { HeatmapChart } from '@silverpoint/react/heatmap-chart';
import { KpiCard } from '@silverpoint/react/kpi-card';
import { LineChart, type ChartHandle } from '@silverpoint/react/line-chart';
import { SpButton } from '@silverpoint/react/ui/button';
import { downloadSvg } from '@/lib/download';
import { advance } from '@/lib/live';
import { blocks, errorsByDay, hourly, sales } from '@/lib/ops';
import { useSettings } from './settings-provider';

const 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' },
  ],
};

export function Overview() {
  const { settings, palette } = useSettings();
  const [rows, setRows] = useState(hourly);
  const [active, setActive] = useState<ActiveItem | null>(null);
  const chart = useRef<ChartHandle>(null);

  useEffect(() => {
    let tick = 0;
    const timer = setInterval(() => {
      tick += 1;
      setRows((current) => advance(current, tick));
    }, 2000);
    return () => clearInterval(timer);
  }, []);

  const last = rows[rows.length - 1];

  const exportChart = () => {
    const svg = chart.current?.toSVGString();
    if (svg) downloadSvg(svg, 'hits-per-hour.svg');
  };

  return (
    <>
      <Dashboard
        id="ops"
        title="Operations"
        description="Traffic, errors and sales of the web service today."
        layout={layout}
        link={{ key: 'hour' }}
        ground={settings.ground}
        palette={palette}
      >
        <DashboardCell cell="hits-today">
          <KpiCard title="Hits today" data={hourly} valueKey="hits" value={886} unit="thousand hits" delta={4.2} />
        </DashboardCell>
        <DashboardCell cell="errors-today">
          <KpiCard title="Errors today" data={hourly} valueKey="errors" value={103} unit="errors" delta={-12} />
        </DashboardCell>
        <DashboardCell cell="traffic">
          <LineChart
            ref={chart}
            id="live-hits"
            title="Hits per hour"
            badge="Live"
            data={rows}
            xKey="hour"
            valueKey="hits"
            footerLeft="Thousands"
            footerRight={`Updated at ${last.hour}:00`}
            onActiveChange={setActive}
          />
        </DashboardCell>
        <DashboardCell cell="errors-hour">
          <BarChart title="Errors per hour" data={hourly} xKey="hour" valueKey="errors" />
        </DashboardCell>
        <DashboardCell cell="errors-day">
          <HeatmapChart
            title="Errors by day"
            data={errorsByDay}
            labelKey="day"
            valuesKey="values"
            columnLabels={blocks}
            scaleMax={40}
          />
        </DashboardCell>
        <DashboardCell cell="channels">
          <DonutChart title="Sales by channel" data={sales} nameKey="channel" valueKey="sales" centerLabel="thousand EUR" />
        </DashboardCell>
      </Dashboard>
      <div className="toolbar">
        <SpButton onClick={exportChart}>Download SVG</SpButton>
        <p>{active ? `${String(active.datum.hour)}:00, ${active.value}k hits` : 'Point at an hour'}</p>
      </div>
    </>
  );
}

Lo que hace cada parte:

  • Los datos en vivo. El intervalo del artículo 20 añade una lectura cada 2 segundos y descarta la más antigua. El gráfico de tráfico lleva id="live-hits", un identificador estable: sin él, cada render podría cambiar la semilla y el trazo temblaría de otra forma en cada lectura. El pie dice la hora de la última lectura.
  • Los gráficos enlazados. Con link={{ key: 'hour' }}, el puntero sobre una hora del tráfico marca la misma hora en los errores y en las curvas de los dos indicadores, y al revés. Los errores por día y las ventas por canal no tienen el campo hour: no muestran marca y en desarrollo avisan con SP016, como explicaba el artículo 13.
  • La lectura. onActiveChange del gráfico de tráfico guarda el elemento activo, como en el artículo 11, y el párrafo escribe «11:00, 62k hits». Solo sigue al gráfico de tráfico: las marcas que pone el enlace no lo cambian. Para seguir el valor enlazado, usa onLinkChange, del artículo 13.
  • La descarga. ref da el manejador del gráfico, y toSVGString() el SVG, como en el artículo 18. El archivo lleva la paleta del tema elegido.
  • El tema del panel. ground y palette se pasan al Dashboard, además de llegar por el proveedor. Desde la 0.10.0 el marco del panel ya sigue al proveedor (issue #17), pero en esta aplicación los dos valores siguen haciendo falta. Cuando cambias el tema en /settings, la vista general está oculta. Sin ellos, al volver en la versión de producción, el marco tomaba el tema nuevo y los seis gráficos seguían con el anterior hasta la siguiente lectura en vivo, unos 2 segundos después. Con ellos, Overview lee los ajustes, se vuelve a dibujar al mostrarse y todo cambia a la vez.

Las incidencias

app/incidents/page.tsx es de servidor, con su título y su encabezado:

import type { Metadata } from 'next';
import { Incidents } from './incidents';

export const metadata: Metadata = { title: 'Incidents' };

export default function IncidentsPage() {
  return (
    <>
      <h1>Incidents</h1>
      <Incidents />
    </>
  );
}

app/incidents/incidents.tsx es el componente Incidents del artículo 17 con tres cambios: la primera línea, 'use client'; la ruta de los datos, que ahora están en lib/; y la clase stack en la section. El principio del archivo queda así:

'use client';

import { useState } from 'react';
import { uiSortRows } from '@silverpoint/core/ui';
import { SpButton } from '@silverpoint/react/ui/button';
import { SpModal } from '@silverpoint/react/ui/modal';
import { SpPagination } from '@silverpoint/react/ui/pagination';
import { SpSelect } from '@silverpoint/react/ui/select';
import { SpTable } from '@silverpoint/react/ui/table';
import { SpToast, SpToaster } from '@silverpoint/react/ui/toast';
import { COLUMNS, INCIDENTS, PAGE_SIZE } from '@/lib/incidents';

El resto es igual: la tabla ordenable, la paginación de cinco en cinco, la ventana con su botón nativo como disparador y el aviso.

Los ajustes

app/settings/page.tsx pone los dos bloques, uno junto al otro en una pantalla ancha:

import type { Metadata } from 'next';
import { AlertRuleForm } from './alert-rule-form';
import { ThemeForm } from './theme-form';

export const metadata: Metadata = { title: 'Settings' };

export default function SettingsPage() {
  return (
    <>
      <h1>Settings</h1>
      <div className="settings">
        <section className="stack">
          <h2>Theme</h2>
          <ThemeForm />
        </section>
        <section className="stack">
          <h2>Alert rule</h2>
          <AlertRuleForm />
        </section>
      </div>
    </>
  );
}

app/settings/theme-form.tsx cambia el tema. No tiene botón de guardar: cada cambio se aplica al momento.

'use client';

import { PALETTE_NAMES } from '@silverpoint/core/palettes';
import { SpSegmented } from '@silverpoint/react/ui/segmented';
import { SpSelect } from '@silverpoint/react/ui/select';
import { useSettings } from '../settings-provider';

const GROUNDS = [
  { key: 'silverpoint', label: 'Silverpoint' },
  { key: 'cyanotype', label: 'Cyanotype' },
];

export function ThemeForm() {
  const { settings, update } = useSettings();

  return (
    <>
      <SpSegmented
        label="Ground"
        name="ground"
        items={GROUNDS}
        value={settings.ground}
        onChange={(ground) => update({ ground: ground === 'cyanotype' ? 'cyanotype' : 'silverpoint' })}
      />
      <SpSelect
        label="Palette"
        items={PALETTE_NAMES}
        value={settings.palette}
        onChange={(name) => {
          const palette = PALETTE_NAMES.find((candidate) => candidate === name);
          if (palette) update({ palette });
        }}
        disabled={settings.ground === 'cyanotype'}
      />
    </>
  );
}

PALETTE_NAMES son los nombres de las seis paletas, de silverpoint a indigo. Al elegir uno, update lo guarda, el proveedor recibe la paleta nueva y todo lo que está debajo se vuelve a pintar: los gráficos, el panel, la tabla, los botones y el fondo de la página. Al cambiar de paleta, los datos no se vuelven a dibujar: solo cambian las propiedades --sp-*.

SpSelect entrega un string en onChange, y palette es un PaletteName, el tipo de los seis nombres desde la 0.10.0 (issue #20). Por eso el nombre se busca en PALETTE_NAMES antes de guardarlo.

app/settings/alert-rule-form.tsx es el formulario del artículo 16. Sus campos empiezan con la regla guardada y, al enviar, la guardan en los ajustes:

'use client';

import { useState, type FormEvent } from 'react';
import { SpButton } from '@silverpoint/react/ui/button';
import { SpRadioGroup } from '@silverpoint/react/ui/radio-group';
import { SpSegmented } from '@silverpoint/react/ui/segmented';
import { SpSlider } from '@silverpoint/react/ui/slider';
import { SpSwitch } from '@silverpoint/react/ui/switch';
import { SpTextarea } from '@silverpoint/react/ui/textarea';
import { describeRule } from '@/lib/rule';
import { useSettings } from '../settings-provider';

const METRICS = [
  { key: 'errors', label: 'Errors' },
  { key: 'hits', label: 'Hits' },
];

const CHANNELS = [
  { key: 'email', label: 'Email' },
  { key: 'chat', label: 'Chat' },
  { key: 'sms', label: 'SMS', disabled: true },
];

export function AlertRuleForm() {
  const { settings, update } = useSettings();
  const [metric, setMetric] = useState(settings.rule.metric);
  const [threshold, setThreshold] = useState(settings.rule.threshold);
  const [channel, setChannel] = useState(settings.rule.channel);
  const [active, setActive] = useState(settings.rule.active);

  function save(event: FormEvent<HTMLFormElement>) {
    event.preventDefault();
    const notes = String(new FormData(event.currentTarget).get('notes') ?? '');
    update({ rule: { metric, threshold, channel, active, notes } });
  }

  return (
    <form onSubmit={save}>
      <SpSegmented label="Metric" name="metric" items={METRICS} value={metric} onChange={setMetric} />
      <SpSlider
        label="Threshold"
        name="threshold"
        min={0}
        max={50}
        step={5}
        marks={[0, 25, 50]}
        value={threshold}
        onChange={setThreshold}
      />
      <SpRadioGroup
        label="Notify by"
        name="channel"
        items={CHANNELS}
        orientation="horizontal"
        value={channel}
        onChange={setChannel}
      />
      <SpSwitch label="Active" name="active" checked={active} onChange={setActive} />
      <SpTextarea
        label="Notes"
        placeholder="Notes for the on-call team"
        name="notes"
        rows={2}
        maxLength={200}
        showCount
        defaultValue={settings.rule.notes}
      />
      <SpButton type="submit" variant="primary">
        Save rule
      </SpButton>
      <p role="status">Saved rule: {describeRule(settings.rule)}</p>
    </form>
  );
}

Lo que Next.js conserva al navegar

La plantilla activa cacheComponents. Con esa opción, Next.js no desmonta la página que dejas: la oculta con el componente <Activity> de React y conserva su estado y su HTML. Lo hace con las tres últimas rutas visitadas, que en esta aplicación son todas.

Lo comprobé en la versión de producción:

  • Reconocí INC-1038, ordené por minutos, pasé por las otras dos páginas y volví: la tabla seguía ordenada por minutos e INC-1038 seguía como acknowledged.
  • Mientras la vista general está oculta, React desmonta sus efectos, así que el intervalo se detiene. Al volver tras 6,5 segundos, el pie seguía en «Updated at 01:00», y 2 segundos después pasó a «Updated at 02:00»: la ventana sigue desde donde se quedó, sin saltos.
  • Al salir de la vista general no aparece ningún aviso en la consola, tampoco en desarrollo. Hasta la 0.9.2, cada gráfico oculto avisaba con SP003, porque un elemento con display: none mide 0 px. Desde la 0.10.0, un gráfico oculto conserva su último ancho (silverpoint#22).

Por eso guardar la regla en los ajustes no es imprescindible con tres rutas: el formulario también se conservaría oculto. Pero una aplicación con más páginas pierde las más antiguas, y los ajustes deben vivir en un sitio que no dependa de eso.

Ejecutar, compilar y desplegar

En desarrollo:

npm run dev

La aplicación queda en http://localhost:3000. Para la versión de producción:

npm run build
npm run start

npm run build compiló en 7,6 segundos y marcó las cuatro rutas como estáticas:

Route (app)
┌ ○ /
├ ○ /_not-found
├ ○ /incidents
└ ○ /settings


○  (Static)  prerendered as static content

Las cuatro se generan como HTML al compilar. No hay nada que calcular por petición: los datos son fijos y los datos en vivo se generan en el navegador.

Para desplegar en Vercel, sube el proyecto a un repositorio de Git e impórtalo desde vercel.com/new. Vercel reconoce Next.js y usa next build sin configuración. También puedes desplegar desde la carpeta del proyecto con su línea de comandos, npx vercel. Las páginas estáticas se sirven desde la red de Vercel, y cada envío al repositorio crea un despliegue nuevo con su propia dirección. No hay variables de entorno que configurar. Yo no lo desplegué; lo probé con npm run start.

Las comprobaciones

Probé la aplicación con Playwright y Chrome, primero contra npm run dev y después contra la versión de producción, con 29 comprobaciones. Todas pasaron en los dos casos. Las principales:

QuéCómoResultado
El panelEsperar los seis .sp-root con data-status="ready"Los seis listos, también en el HTML sin JavaScript
Los datos en vivoLeer el pie del tráfico, esperar 4,5 s y volver a leerlo«Updated at 23:00» pasa a «Updated at 01:00»
El enlacePasar el puntero por las barras de erroresLa hora se marca en el tráfico y en los dos indicadores
La lecturaPasar el puntero por el tráfico«14:00, 59k hits»; al salir, «Point at an hour»
La descargaPulsar «Download SVG»hits-per-hour.svg, con <style><![CDATA[ y el estilo base; abierto solo en Chrome, se ve igual que en la página
La tablaPulsar el encabezado «Minutes»La primera fila pasa de INC-1042 a INC-1041
La ventana y el avisoElegir INC-1038 y pulsar «Acknowledge»La ventana se cierra y aparece «INC-1038 no longer pages the on-call team.»
El formularioElegir Hits, desactivar Active, escribir una nota y guardar«Saved rule: hits ≥ 10, by email, paused. Notes: Page the database team», y sigue igual al volver a la página
La cianotipiaElegirla en /settings y volver a la vista generalEl fondo de la página y del panel pasa a rgb(27, 63, 107), los seis gráficos llevan sp-ground-cyanotype y la tabla escribe en blanco
Una paletaVolver a Silverpoint y elegir sanguineEl fondo pasa a rgb(242, 232, 220), los gráficos llevan --sp-ink: #8A3A24, y el SVG descargado también
La consolaRecoger errores y avisosEn producción, ninguno. En desarrollo, solo SP016, explicado arriba

También pasaron npx tsc --noEmit y la compilación de producción, que comprueba los tipos.

Lo que cuesta

Medí la versión de producción con gzip:

RutaHTMLJavaScriptCSS
/77,8 kB (11,7 kB con gzip)734,0 kB (230,0 kB con gzip)150,0 kB (15,3 kB con gzip)
/incidents18,2 kB (3,8 kB con gzip)694,6 kB (217,3 kB con gzip)150,0 kB (15,3 kB con gzip)
/settings17,8 kB (3,7 kB con gzip)692,8 kB (216,6 kB con gzip)150,0 kB (15,3 kB con gzip)

El HTML de / pesa más porque trae los seis gráficos dibujados. Los seis gráficos estaban listos 25 ms después de empezar la navegación, en mediana de tres cargas en mi máquina y en local: llegan en el HTML.

El JavaScript es parecido en las tres rutas. Con silverpoint 0.9.2 pesaba más: 995,2 kB en / y 1025 kB entre todas las rutas. El proveedor se importaba de la entrada general, @silverpoint/react, que contiene todos los gráficos, y Turbopack no descartaba los que la aplicación no usa (silverpoint#21). Con la 0.10.1, el total es 763,7 kB, 239,7 kB con gzip.

La 0.10.0 añadió además una ruta propia para el proveedor, @silverpoint/react/provider, que es la que usa settings-provider.tsx. En esta aplicación medí lo mismo importándolo de una ruta o de la otra.

La hoja de los componentes de interfaz, ui.css, es la mayor parte del CSS.

Problemas comunes

  • Can't resolve '@silverpoint/grounds/styles.css' con ?raw. Turbopack no aplica la consulta a la ruta del paquete. Importa la hoja de @silverpoint/grounds/styles-text, sin ?raw.
  • La compilación falla con TS7053 en PALETTES[...]. Desde la 0.10.0, PALETTES solo acepta los seis nombres de PaletteName. Declara palette con ese tipo, no como string.
  • Un gráfico no cambia con el tema. Es un componente de servidor, que no lee el contexto. Pasa el gráfico a un componente de cliente.
  • Al volver de /settings, los gráficos del panel siguen con el tema anterior durante unos segundos. Faltan ground y palette en el Dashboard. Pásalos desde el componente que lo dibuja, como en app/overview.tsx.
  • El panel tiene dos columnas en una pantalla ancha. Una regla de tu CSS sobre section le pone un ancho máximo: Dashboard es una section.
  • Avisos SP003 al cambiar de página en desarrollo. Tienes una versión anterior a la 0.10.0, que avisaba por los gráficos de la página oculta (silverpoint#22).
  • useSettings() needs a <SettingsProvider> above it. El componente se renderiza fuera de SettingsProvider. Todo lo que use useSettings() tiene que estar dentro de una página o del diseño común, bajo app/layout.tsx.

Lo que viene

El artículo 24 construye la misma aplicación en Vue, con Vite y vue-router. Las páginas, los datos y las comprobaciones son los mismos, para que el artículo 27 pueda comparar las cuatro versiones.