npm - @ressjs/vite-router - Versions diffs - 0.5.2 → 0.6.0-experimental.0 - Mend

@ressjs/vite-router 0.5.2 → 0.6.0-experimental.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (110) hide show

package/README.md +42 -32
package/dist/client/entry.d.mts +2 -0
package/dist/client/entry.mjs +1 -0
package/dist/client/index.d.ts +2 -0
package/dist/client/index.js +8 -0
package/dist/config/base-path.d.ts +44 -0
package/dist/config/base-path.js +100 -0
package/dist/config/codegen.d.ts +23 -0
package/dist/config/codegen.js +118 -0
package/dist/config/define.d.ts +8 -0
package/dist/config/define.js +12 -0
package/dist/config/env.d.ts +19 -0
package/dist/config/env.js +40 -0
package/dist/config/index.d.ts +18 -0
package/dist/config/index.js +44 -0
package/dist/config/load.d.ts +26 -0
package/dist/config/load.js +73 -0
package/dist/config/middleware.d.ts +18 -0
package/dist/config/middleware.js +79 -0
package/dist/config/rules.d.ts +48 -0
package/dist/config/rules.js +149 -0
package/dist/config/types.d.ts +164 -0
package/dist/config/types.js +2 -0
package/dist/config/validate.d.ts +19 -0
package/dist/config/validate.js +105 -0
package/dist/config/watch.d.ts +41 -0
package/dist/config/watch.js +132 -0
package/dist/fs/module-extensions.d.ts +82 -0
package/dist/fs/module-extensions.js +196 -0
package/dist/helpers/html-generator.d.ts +22 -5
package/dist/helpers/html-generator.js +89 -120
package/dist/helpers/middlewares.d.ts +7 -7
package/dist/helpers/middlewares.js +51 -105
package/dist/helpers/request-handler.d.ts +2 -2
package/dist/helpers/request-handler.js +118 -25
package/dist/index.d.ts +30 -3
package/dist/index.js +70 -8
package/dist/pages.d.ts +10 -9
package/dist/pages.js +42 -261
package/dist/platform.d.ts +11 -14
package/dist/platform.js +18 -102
package/dist/plugin/environments.d.ts +66 -0
package/dist/plugin/environments.js +72 -0
package/dist/plugin/index.d.ts +54 -0
package/dist/plugin/index.js +178 -0
package/dist/plugin/virtual-entries.d.ts +26 -0
package/dist/plugin/virtual-entries.js +80 -0
package/dist/render.d.ts +23 -2
package/dist/render.js +40 -53
package/dist/router.d.ts +32 -13
package/dist/router.js +147 -146
package/dist/routes/dispatcher.d.ts +37 -0
package/dist/routes/dispatcher.js +69 -0
package/dist/routes/manifest.d.ts +17 -0
package/dist/routes/manifest.js +56 -0
package/dist/routes/match.d.ts +20 -0
package/dist/routes/match.js +75 -0
package/dist/routes/parse.d.ts +31 -0
package/dist/routes/parse.js +114 -0
package/dist/routes/rank.d.ts +12 -0
package/dist/routes/rank.js +49 -0
package/dist/routes/router.d.ts +44 -0
package/dist/routes/router.js +81 -0
package/dist/routes/scan.d.ts +16 -0
package/dist/routes/scan.js +82 -0
package/dist/routes/types.d.ts +85 -0
package/dist/routes/types.js +13 -0
package/dist/runtime/dev-server.d.ts +62 -0
package/dist/runtime/dev-server.js +94 -0
package/dist/runtime/module-loader.d.ts +55 -0
package/dist/runtime/module-loader.js +122 -0
package/dist/runtime/prod-server.d.ts +42 -0
package/dist/runtime/prod-server.js +142 -0
package/dist/runtime/template.d.ts +10 -0
package/dist/runtime/template.js +33 -0
package/dist/security/client-props.d.ts +25 -0
package/dist/security/client-props.js +50 -0
package/dist/security/config.d.ts +130 -0
package/dist/security/config.js +73 -0
package/dist/security/csp.d.ts +53 -0
package/dist/security/csp.js +118 -0
package/dist/security/dev-hardening.d.ts +46 -0
package/dist/security/dev-hardening.js +65 -0
package/dist/security/errors.d.ts +37 -0
package/dist/security/errors.js +84 -0
package/dist/security/escape.d.ts +40 -0
package/dist/security/escape.js +90 -0
package/dist/security/head-tags.d.ts +32 -0
package/dist/security/head-tags.js +111 -0
package/dist/security/headers.d.ts +62 -0
package/dist/security/headers.js +187 -0
package/dist/security/index.d.ts +24 -0
package/dist/security/index.js +47 -0
package/dist/security/serialize.d.ts +48 -0
package/dist/security/serialize.js +146 -0
package/dist/variants/assets.d.ts +23 -0
package/dist/variants/assets.js +78 -0
package/dist/variants/catalog.d.ts +33 -0
package/dist/variants/catalog.js +79 -0
package/dist/variants/platform-tokens.d.ts +9 -0
package/dist/variants/platform-tokens.js +15 -0
package/dist/variants/resolve.d.ts +40 -0
package/dist/variants/resolve.js +90 -0
package/dist/variants/suffix.d.ts +8 -0
package/dist/variants/suffix.js +12 -0
package/dist/variants/types.d.ts +69 -0
package/dist/variants/types.js +2 -0
package/package.json +22 -10
package/dist/helpers/vite-config.d.ts +0 -10
package/dist/helpers/vite-config.js +0 -90

package/dist/security/head-tags.js ADDED Viewed

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Qué puede poner una página en el `<head>`.
+ *
+ * El `<head>` es el lugar más rentable para inyectar algo: un `<script>` ahí
+ * corre antes que la página, un `<meta http-equiv="refresh">` la redirige, y un
+ * `<base>` cambia a dónde apunta cada URL relativa del documento. Por eso lo que
+ * se admite es una lista cerrada y no una lista de lo prohibido.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEAD_TAG_ALLOWLIST = void 0;
+exports.renderHeadTags = renderHeadTags;
+const escape_1 = require("./escape");
+exports.HEAD_TAG_ALLOWLIST = ['meta', 'link', 'title', 'base', 'style'];
+/** Etiquetas sin contenido, que se emiten autocerradas. */
+const VOID_TAGS = new Set(['meta', 'link', 'base']);
+/**
+ * Valores de `rel` admitidos en un `<link>`.
+ *
+ * Fuera de esta lista quedan cosas como `import`, que carga y ejecuta un
+ * documento entero.
+ */
+const LINK_REL_ALLOWLIST = new Set([
+    'stylesheet',
+    'preload',
+    'prefetch',
+    'preconnect',
+    'dns-prefetch',
+    'icon',
+    'apple-touch-icon',
+    'manifest',
+    'canonical',
+    'alternate',
+    'modulepreload',
+]);
+/**
+ * `http-equiv` que se descartan: uno redirige la página y el otro declara una
+ * política de contenido que debilitaría la que emite el framework por cabecera.
+ */
+const BLOCKED_HTTP_EQUIV = new Set(['refresh', 'content-security-policy']);
+/**
+ * Filtra y emite las etiquetas adicionales del `<head>`.
+ *
+ * Nunca se concatena un string de HTML crudo que aporte la aplicación: la
+ * entrada es siempre estructurada, y cada atributo pasa por el escapado.
+ */
+function renderHeadTags(tags, ctx, options = {}) {
+    const allowed = new Set([
+        ...exports.HEAD_TAG_ALLOWLIST,
+        ...(options.extraAllowlist ?? []),
+        ...(options.allowScriptTags ? ['script'] : []),
+    ]);
+    const out = [];
+    let baseEmitted = false;
+    for (const tag of tags ?? []) {
+        const name = String(tag?.tag ?? '').toLowerCase();
+        if (!allowed.has(name)) {
+            discard(ctx, name, 'no está entre las etiquetas admitidas en <head>');
+            continue;
+        }
+        if (name === 'base') {
+            if (baseEmitted) {
+                discard(ctx, name, 'ya hay un <base>; sólo se admite uno por documento');
+                continue;
+            }
+            baseEmitted = true;
+        }
+        if (name === 'link' && !isAllowedLink(tag)) {
+            discard(ctx, name, `su rel no está admitido`);
+            continue;
+        }
+        if (name === 'meta' && isBlockedMeta(tag)) {
+            discard(ctx, name, 'su http-equiv no está admitido');
+            continue;
+        }
+        // El contenido de un <style> se emite sin escapar —es CSS, no HTML—, así
+        // que lo único que puede sacarlo de su elemento es un cierre literal.
+        if (name === 'style' && /<\/style/i.test(tag.children ?? '')) {
+            discard(ctx, name, 'su contenido cierra el elemento');
+            continue;
+        }
+        out.push(emit(name, tag, options.nonce));
+    }
+    return out.join('\n');
+}
+function emit(name, tag, nonce) {
+    const attrs = { ...(tag.attrs ?? {}) };
+    if (nonce && (name === 'style' || name === 'script'))
+        attrs.nonce = nonce;
+    const rendered = (0, escape_1.renderAttrs)(attrs, { where: `<${name}>`, isProduction: true });
+    const open = rendered ? `<${name} ${rendered}` : `<${name}`;
+    if (VOID_TAGS.has(name))
+        return `${open}>`;
+    // El CSS de un <style> se emite tal cual; todo lo demás es texto y se escapa.
+    const body = name === 'style' ? (tag.children ?? '') : (0, escape_1.escapeHtmlText)(tag.children ?? '');
+    return `${open}>${body}</${name}>`;
+}
+function isAllowedLink(tag) {
+    const rel = String(tag.attrs?.rel ?? '').toLowerCase().trim();
+    return rel !== '' && rel.split(/\s+/).every((r) => LINK_REL_ALLOWLIST.has(r));
+}
+function isBlockedMeta(tag) {
+    const httpEquiv = String(tag.attrs?.['http-equiv'] ?? '').toLowerCase().trim();
+    return BLOCKED_HTTP_EQUIV.has(httpEquiv);
+}
+function discard(ctx, name, why) {
+    if (ctx.isProduction)
+        return;
+    const where = ctx.route ? ` de ${ctx.route}` : '';
+    console.warn(`[ress] etiqueta <${name}> descartada en <head>${where}: ${why}.`);
+}

package/dist/security/headers.d.ts ADDED Viewed

@@ -0,0 +1,62 @@
+/**
+ * Cabeceras de la respuesta.
+ *
+ * Todas se emiten **antes** de escribir el cuerpo: una vez que la respuesta
+ * empezó a escribirse ya no se pueden cambiar, y el intento tira una excepción
+ * que enmascara el error original.
+ */
+import type { ServerResponse } from 'node:http';
+import { type Axis } from '@ressjs/platform';
+import type { ResolvedSecurityOptions } from './config';
+export interface HeaderContext {
+    isProduction: boolean;
+    /**
+     * Ejes por los que **esta** respuesta varía.
+     *
+     * Sale de las variantes que la página declara: una página sin variantes
+     * devuelve el mismo documento a cualquier cliente, y declarar que varía por
+     * dieciocho cabeceras obliga a una caché intermedia a guardar una entrada por
+     * combinación de algo que no cambia nunca.
+     *
+     * Vacío o `null` significa que no se emite `Vary` de plataforma.
+     */
+    varyBy?: readonly Axis[] | null;
+    /** Cabeceras de la red de distribución que el proyecto declaró. */
+    edge?: readonly {
+        header: string;
+        axis: string;
+    }[];
+    nonce?: string;
+    kind: 'html' | 'error';
+}
+/**
+ * Agrega campos a `Vary` sin duplicar y sin reemplazar lo que ya haya.
+ *
+ * Reemplazar sería destruir el trabajo de un middleware anterior: si alguien
+ * declaró `Vary: Accept-Language` porque su respuesta depende del idioma, y el
+ * framework lo pisa, el CDN sirve la traducción equivocada.
+ *
+ * Un `Vary: *` existente no se toca: ya es más restrictivo que cualquier lista.
+ */
+export declare function appendVary(res: ServerResponse, fields: readonly string[]): void;
+/**
+ * Aplica las cabeceras de seguridad de una respuesta.
+ *
+ * Es idempotente y no pisa lo que la aplicación ya haya definido, con dos
+ * excepciones: `Vary`, que amplía, y el `Content-Type` del HTML, que fija —el
+ * `charset` explícito es parte del endurecimiento, porque sin él un navegador
+ * puede inferir una codificación en la que los mismos bytes significan otra cosa.
+ */
+export declare function applySecurityHeaders(res: ServerResponse, opts: ResolvedSecurityOptions, ctx: HeaderContext): void;
+/**
+ * Cuánto puede cachearse un archivo estático.
+ *
+ * Un nombre con hash de contenido cambia cuando cambia el contenido, así que se
+ * puede guardar para siempre. Cualquier otro nombre puede volver a servirse con
+ * contenido distinto, y un archivo guardado como inmutable por error es
+ * irrecuperable: no hay forma de invalidarlo en el navegador de quien ya lo
+ * bajó. Por eso el default es revalidar.
+ */
+export declare function classifyAsset(pathname: string, buildOutputs: ReadonlySet<string>): 'immutable' | 'revalidate';
+/** El valor de `Cache-Control` de un archivo estático según su clase. */
+export declare function assetCacheControl(kind: 'immutable' | 'revalidate', opts: ResolvedSecurityOptions): string;

package/dist/security/headers.js ADDED Viewed

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Cabeceras de la respuesta.
+ *
+ * Todas se emiten **antes** de escribir el cuerpo: una vez que la respuesta
+ * empezó a escribirse ya no se pueden cambiar, y el intento tira una excepción
+ * que enmascara el error original.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendVary = appendVary;
+exports.applySecurityHeaders = applySecurityHeaders;
+exports.classifyAsset = classifyAsset;
+exports.assetCacheControl = assetCacheControl;
+const platform_1 = require("@ressjs/platform");
+/**
+ * Agrega campos a `Vary` sin duplicar y sin reemplazar lo que ya haya.
+ *
+ * Reemplazar sería destruir el trabajo de un middleware anterior: si alguien
+ * declaró `Vary: Accept-Language` porque su respuesta depende del idioma, y el
+ * framework lo pisa, el CDN sirve la traducción equivocada.
+ *
+ * Un `Vary: *` existente no se toca: ya es más restrictivo que cualquier lista.
+ */
+function appendVary(res, fields) {
+    const current = res.getHeader('Vary');
+    const existing = Array.isArray(current) ? current.join(', ') : String(current ?? '');
+    if (existing.trim() === '*')
+        return;
+    const present = new Set(existing
+        .split(',')
+        .map((f) => f.trim().toLowerCase())
+        .filter(Boolean));
+    const merged = existing ? [existing.trim()] : [];
+    for (const field of fields) {
+        if (present.has(field.toLowerCase()))
+            continue;
+        present.add(field.toLowerCase());
+        merged.push(field);
+    }
+    if (merged.length)
+        res.setHeader('Vary', merged.join(', '));
+}
+/**
+ * Aplica las cabeceras de seguridad de una respuesta.
+ *
+ * Es idempotente y no pisa lo que la aplicación ya haya definido, con dos
+ * excepciones: `Vary`, que amplía, y el `Content-Type` del HTML, que fija —el
+ * `charset` explícito es parte del endurecimiento, porque sin él un navegador
+ * puede inferir una codificación en la que los mismos bytes significan otra cosa.
+ */
+function applySecurityHeaders(res, opts, ctx) {
+    if (res.headersSent) {
+        if (!ctx.isProduction) {
+            console.warn('[ress] no se pudieron aplicar las cabeceras de seguridad: la respuesta ya empezó a enviarse.');
+        }
+        return;
+    }
+    const fields = (0, platform_1.varyHeadersForAxes)(ctx.varyBy ?? [], {
+        includeUserAgent: opts.varyOnUserAgent,
+        // Sólo las que el proyecto declaró para su red: declarar cabeceras que nadie
+        // manda vuelve a inflar la clave de caché, que es lo que se quería evitar.
+        edge: ctx.edge,
+    });
+    if (fields.length) {
+        appendVary(res, fields);
+        requestClientHints(res);
+    }
+    if (opts.headers.contentTypeOptions)
+        setIfAbsent(res, 'X-Content-Type-Options', 'nosniff');
+    if (opts.headers.referrerPolicy) {
+        setIfAbsent(res, 'Referrer-Policy', opts.headers.referrerPolicy);
+    }
+    // No se emite por defecto: ress.js sirve páginas embebidas en apps por diseño,
+    // y una política de encuadre rompería el caso de uso principal.
+    if (opts.headers.frameOptions) {
+        setIfAbsent(res, 'X-Frame-Options', opts.headers.frameOptions);
+    }
+    // Apagada por defecto: activarla sobre un dominio que todavía sirve HTTP por
+    // alguna ruta lo deja inaccesible, y esa decisión es del proyecto.
+    if (opts.headers.hsts && ctx.isProduction) {
+        const { maxAge, includeSubDomains, preload } = opts.headers.hsts;
+        setIfAbsent(res, 'Strict-Transport-Security', [
+            `max-age=${maxAge}`,
+            includeSubDomains ? 'includeSubDomains' : '',
+            preload ? 'preload' : '',
+        ]
+            .filter(Boolean)
+            .join('; '));
+    }
+    setIfAbsent(res, 'Content-Type', 'text/html; charset=utf-8');
+    // Un archivo servido como documento por un visor de otra tecnología puede
+    // leer políticas de dominio cruzado que nadie revisó. Cuesta una cabecera.
+    setIfAbsent(res, 'X-Permitted-Cross-Domain-Policies', 'none');
+    // `X-XSS-Protection` no se emite a propósito: el filtro que activaba está
+    // retirado de los navegadores y, donde queda, introduce vulnerabilidades
+    // propias. La política de contenido es lo que lo reemplaza.
+    // Una página de error guardada por un intermediario es un incidente: el
+    // siguiente que pida esa URL recibe el error de otro.
+    if (ctx.kind === 'error') {
+        res.setHeader('Cache-Control', 'no-store');
+    }
+    else {
+        // `private` porque el HTML renderizado en el servidor puede llevar datos de
+        // la sesión. F-010 lo sobrescribe en las rutas que genere estáticamente.
+        setIfAbsent(res, 'Cache-Control', opts.cache.html);
+        forbidSharedCacheIfSettingCookies(res, ctx);
+    }
+}
+/**
+ * Pide al navegador las pistas de plataforma que necesita la resolución.
+ *
+ * `Sec-CH-UA-Form-Factors` es la señal que dice `Desktop`, `Mobile`, `Tablet` o
+ * `TV`: exactamente lo que hoy hay que adivinar del User-Agent, pero con cuatro
+ * valores posibles en vez de cientos de miles. Es de alta entropía, así que el
+ * navegador no la manda salvo que el servidor la pida.
+ *
+ * `Critical-CH` hace que la **primera** petición se reintente ya con la pista,
+ * en lugar de servir una variante adivinada y acertar recién en la segunda.
+ * Cuesta un viaje extra la primera vez y sólo se pide en las páginas que varían.
+ *
+ * Es una mejora para navegadores basados en Chromium. Safari y Firefox no
+ * mandan estas pistas, y para ellos el User-Agent sigue siendo la única señal
+ * disponible en una navegación directa.
+ */
+function requestClientHints(res) {
+    const hints = 'Sec-CH-UA-Platform, Sec-CH-UA-Mobile, Sec-CH-UA-Form-Factors';
+    setIfAbsent(res, 'Accept-CH', hints);
+    setIfAbsent(res, 'Critical-CH', 'Sec-CH-UA-Form-Factors');
+}
+/**
+ * Una respuesta que entrega una cookie no puede guardarse en una caché compartida.
+ *
+ * Si un intermediario la guarda, el siguiente que pida esa URL recibe **la
+ * cookie de otro**: la sesión de una persona pasa a la siguiente. Es de los
+ * incidentes más caros que produce una configuración de caché, y ocurre en
+ * cuanto alguien pone la caché del HTML en `public` sin acordarse de que un
+ * middleware setea una cookie.
+ *
+ * El default `private` ya lo evita; esto protege al proyecto que lo cambió.
+ */
+function forbidSharedCacheIfSettingCookies(res, ctx) {
+    if (!res.getHeader('set-cookie'))
+        return;
+    const current = String(res.getHeader('Cache-Control') ?? '');
+    if (!/\bpublic\b/.test(current))
+        return;
+    res.setHeader('Cache-Control', current.replace(/\bpublic\b/, 'private'));
+    if (!ctx.isProduction) {
+        console.warn('[ress] la respuesta entrega una cookie y su Cache-Control decía `public`. ' +
+            'Se cambió a `private`: una caché compartida le habría entregado esa cookie ' +
+            'a quien pidiera la misma URL después.');
+    }
+}
+function setIfAbsent(res, name, value) {
+    if (res.getHeader(name) === undefined)
+        res.setHeader(name, value);
+}
+/** Nombre de archivo con un hash de contenido: `algo-A1b2C3d4.js`. */
+const HASHED_NAME_RE = /-[A-Za-z0-9_-]{8,}\.[A-Za-z0-9]+$/;
+/**
+ * Cuánto puede cachearse un archivo estático.
+ *
+ * Un nombre con hash de contenido cambia cuando cambia el contenido, así que se
+ * puede guardar para siempre. Cualquier otro nombre puede volver a servirse con
+ * contenido distinto, y un archivo guardado como inmutable por error es
+ * irrecuperable: no hay forma de invalidarlo en el navegador de quien ya lo
+ * bajó. Por eso el default es revalidar.
+ */
+function classifyAsset(pathname, buildOutputs) {
+    const normalized = pathname.replace(/^\//, '');
+    const fileName = normalized.split('/').pop() ?? '';
+    // Un documento cacheado de forma inmutable deja la aplicación congelada.
+    if (fileName.endsWith('.html'))
+        return 'revalidate';
+    // El manifest es la fuente autoritativa: son nombres que generó el
+    // empaquetador y por construcción llevan el hash del contenido.
+    if (buildOutputs.has(normalized))
+        return 'immutable';
+    // Respaldo para los archivos que emite un plugin sin pasar por el manifest.
+    return HASHED_NAME_RE.test(fileName) ? 'immutable' : 'revalidate';
+}
+/** El valor de `Cache-Control` de un archivo estático según su clase. */
+function assetCacheControl(kind, opts) {
+    return kind === 'immutable'
+        ? `public, max-age=${opts.cache.immutableMaxAge}, immutable`
+        : `public, max-age=${opts.cache.staticMaxAge}, must-revalidate`;
+}

package/dist/security/index.d.ts ADDED Viewed

@@ -0,0 +1,24 @@
+/**
+ * Endurecimiento del renderizado en el servidor.
+ *
+ * Reúne lo que protege una respuesta: qué se serializa hacia el cliente, cómo se
+ * escapa lo que llega al documento, qué cabeceras lleva y qué se cuenta cuando
+ * algo falla.
+ */
+export { resolveSecurityOptions } from './config';
+export type { ClientPropsPolicy, ResolvedSecurityOptions, SecurityContext, SecurityOptions, } from './config';
+export { escapeAttrValue, escapeHtmlText, renderAttrs, safeAttrName } from './escape';
+export type { EscapeContext } from './escape';
+export { HEAD_TAG_ALLOWLIST, renderHeadTags } from './head-tags';
+export type { HeadTag, HeadTagOptions } from './head-tags';
+export { checkStateSize, renderStateScript, serializeState, SerializationError, } from './serialize';
+export type { SizeCheck, StateBlock } from './serialize';
+export { appendVary, applySecurityHeaders, assetCacheControl, classifyAsset, } from './headers';
+export type { HeaderContext } from './headers';
+export { buildCsp, cspHeaderName, createNonce, injectNonce, reportingEndpointsHeader, } from './csp';
+export type { CspOptions } from './csp';
+export { logServerError, PublicFacingError, sanitizeError } from './errors';
+export type { PublicError } from './errors';
+export { pickClientProps, withheldKeys } from './client-props';
+export { assertDevServerHardening, DENIED_FILES, devServerDefaults } from './dev-hardening';
+export type { DevServerConfig } from './dev-hardening';

package/dist/security/index.js ADDED Viewed

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Endurecimiento del renderizado en el servidor.
+ *
+ * Reúne lo que protege una respuesta: qué se serializa hacia el cliente, cómo se
+ * escapa lo que llega al documento, qué cabeceras lleva y qué se cuenta cuando
+ * algo falla.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devServerDefaults = exports.DENIED_FILES = exports.assertDevServerHardening = exports.withheldKeys = exports.pickClientProps = exports.sanitizeError = exports.PublicFacingError = exports.logServerError = exports.reportingEndpointsHeader = exports.injectNonce = exports.createNonce = exports.cspHeaderName = exports.buildCsp = exports.classifyAsset = exports.assetCacheControl = exports.applySecurityHeaders = exports.appendVary = exports.SerializationError = exports.serializeState = exports.renderStateScript = exports.checkStateSize = exports.renderHeadTags = exports.HEAD_TAG_ALLOWLIST = exports.safeAttrName = exports.renderAttrs = exports.escapeHtmlText = exports.escapeAttrValue = exports.resolveSecurityOptions = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "resolveSecurityOptions", { enumerable: true, get: function () { return config_1.resolveSecurityOptions; } });
+var escape_1 = require("./escape");
+Object.defineProperty(exports, "escapeAttrValue", { enumerable: true, get: function () { return escape_1.escapeAttrValue; } });
+Object.defineProperty(exports, "escapeHtmlText", { enumerable: true, get: function () { return escape_1.escapeHtmlText; } });
+Object.defineProperty(exports, "renderAttrs", { enumerable: true, get: function () { return escape_1.renderAttrs; } });
+Object.defineProperty(exports, "safeAttrName", { enumerable: true, get: function () { return escape_1.safeAttrName; } });
+var head_tags_1 = require("./head-tags");
+Object.defineProperty(exports, "HEAD_TAG_ALLOWLIST", { enumerable: true, get: function () { return head_tags_1.HEAD_TAG_ALLOWLIST; } });
+Object.defineProperty(exports, "renderHeadTags", { enumerable: true, get: function () { return head_tags_1.renderHeadTags; } });
+var serialize_1 = require("./serialize");
+Object.defineProperty(exports, "checkStateSize", { enumerable: true, get: function () { return serialize_1.checkStateSize; } });
+Object.defineProperty(exports, "renderStateScript", { enumerable: true, get: function () { return serialize_1.renderStateScript; } });
+Object.defineProperty(exports, "serializeState", { enumerable: true, get: function () { return serialize_1.serializeState; } });
+Object.defineProperty(exports, "SerializationError", { enumerable: true, get: function () { return serialize_1.SerializationError; } });
+var headers_1 = require("./headers");
+Object.defineProperty(exports, "appendVary", { enumerable: true, get: function () { return headers_1.appendVary; } });
+Object.defineProperty(exports, "applySecurityHeaders", { enumerable: true, get: function () { return headers_1.applySecurityHeaders; } });
+Object.defineProperty(exports, "assetCacheControl", { enumerable: true, get: function () { return headers_1.assetCacheControl; } });
+Object.defineProperty(exports, "classifyAsset", { enumerable: true, get: function () { return headers_1.classifyAsset; } });
+var csp_1 = require("./csp");
+Object.defineProperty(exports, "buildCsp", { enumerable: true, get: function () { return csp_1.buildCsp; } });
+Object.defineProperty(exports, "cspHeaderName", { enumerable: true, get: function () { return csp_1.cspHeaderName; } });
+Object.defineProperty(exports, "createNonce", { enumerable: true, get: function () { return csp_1.createNonce; } });
+Object.defineProperty(exports, "injectNonce", { enumerable: true, get: function () { return csp_1.injectNonce; } });
+Object.defineProperty(exports, "reportingEndpointsHeader", { enumerable: true, get: function () { return csp_1.reportingEndpointsHeader; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "logServerError", { enumerable: true, get: function () { return errors_1.logServerError; } });
+Object.defineProperty(exports, "PublicFacingError", { enumerable: true, get: function () { return errors_1.PublicFacingError; } });
+Object.defineProperty(exports, "sanitizeError", { enumerable: true, get: function () { return errors_1.sanitizeError; } });
+var client_props_1 = require("./client-props");
+Object.defineProperty(exports, "pickClientProps", { enumerable: true, get: function () { return client_props_1.pickClientProps; } });
+Object.defineProperty(exports, "withheldKeys", { enumerable: true, get: function () { return client_props_1.withheldKeys; } });
+var dev_hardening_1 = require("./dev-hardening");
+Object.defineProperty(exports, "assertDevServerHardening", { enumerable: true, get: function () { return dev_hardening_1.assertDevServerHardening; } });
+Object.defineProperty(exports, "DENIED_FILES", { enumerable: true, get: function () { return dev_hardening_1.DENIED_FILES; } });
+Object.defineProperty(exports, "devServerDefaults", { enumerable: true, get: function () { return dev_hardening_1.devServerDefaults; } });

package/dist/security/serialize.d.ts ADDED Viewed

@@ -0,0 +1,48 @@
+/**
+ * Serialización del estado que viaja al cliente.
+ *
+ * El JSON se embebe en un `<script>` inline, así que además de ser JSON válido
+ * tiene que sobrevivir a dos gramáticas más: la del HTML, que busca `</script`,
+ * `<!--` y `<!` dentro del elemento, y la de JavaScript, donde U+2028 y U+2029
+ * son terminadores de línea que parten un literal de cadena.
+ */
+export declare class SerializationError extends Error {
+    readonly reason: string;
+    readonly path: string;
+    constructor(reason: string, path: string);
+}
+/**
+ * Serializa un valor para embeberlo en un `<script>` inline.
+ *
+ * El resultado es JSON válido y `JSON.parse` lo devuelve idéntico al original.
+ */
+export declare function serializeState(value: unknown, path?: string): string;
+export interface StateBlock {
+    /** Nombre de la variable global. Ej: `__RESS_PROPS__`. */
+    varName: string;
+    value: unknown;
+}
+/**
+ * El bloque `<script>` con el estado.
+ *
+ * Recibe el nonce cuando hay política de contenido: sin él, el bloque no se
+ * ejecuta y la hidratación no encuentra sus props.
+ */
+export declare function renderStateScript(blocks: StateBlock[], nonce?: string): string;
+export interface SizeCheck {
+    bytes: number;
+    overLimit: boolean;
+    /** Las claves de primer nivel más pesadas: es lo que hace accionable el aviso. */
+    heaviest: Array<{
+        key: string;
+        bytes: number;
+    }>;
+}
+/**
+ * Cuánto pesa el estado que viaja.
+ *
+ * Se mide sobre el string **ya serializado y escapado**, que es lo que
+ * efectivamente se transfiere, y en bytes y no en caracteres, porque un
+ * carácter fuera de ASCII ocupa más de uno.
+ */
+export declare function checkStateSize(serialized: string, limitBytes: number, value?: unknown): SizeCheck;

package/dist/security/serialize.js ADDED Viewed

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Serialización del estado que viaja al cliente.
+ *
+ * El JSON se embebe en un `<script>` inline, así que además de ser JSON válido
+ * tiene que sobrevivir a dos gramáticas más: la del HTML, que busca `</script`,
+ * `<!--` y `<!` dentro del elemento, y la de JavaScript, donde U+2028 y U+2029
+ * son terminadores de línea que parten un literal de cadena.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializationError = void 0;
+exports.serializeState = serializeState;
+exports.renderStateScript = renderStateScript;
+exports.checkStateSize = checkStateSize;
+const escape_1 = require("./escape");
+/**
+ * Los cinco caracteres a escapar, y ninguno más.
+ *
+ * Escapar `<` neutraliza `</script>`, `<!--`, `<script` y `<!` de una sola vez,
+ * sin tener que reconocer secuencias. `&` va en la lista para que un analizador
+ * que decodifique entidades no pueda reconstruir un `<`.
+ *
+ * Los cinco reemplazos son escapes JSON válidos: `<` **es** `<` para
+ * `JSON.parse`, así que el valor no cambia, sólo su representación.
+ */
+const ESCAPE_MAP = {
+    '<': '\\u003C',
+    '>': '\\u003E',
+    '&': '\\u0026',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029',
+};
+const ESCAPE_RE = /[<>&\u2028\u2029]/g;
+class SerializationError extends Error {
+    reason;
+    path;
+    constructor(reason, path) {
+        super(`[ress] no se pudo serializar el estado en ${path}: ${reason}`);
+        this.reason = reason;
+        this.path = path;
+        this.name = 'SerializationError';
+    }
+}
+exports.SerializationError = SerializationError;
+/**
+ * Serializa un valor para embeberlo en un `<script>` inline.
+ *
+ * El resultado es JSON válido y `JSON.parse` lo devuelve idéntico al original.
+ */
+function serializeState(value, path = '$') {
+    let json;
+    try {
+        json = JSON.stringify(value, createGuard(path));
+    }
+    catch (err) {
+        throw new SerializationError(describe(err), path);
+    }
+    if (json === undefined)
+        return 'undefined';
+    return json.replace(ESCAPE_RE, (c) => ESCAPE_MAP[c]);
+}
+/**
+ * Detecta lo que no es serializable **antes** de que falle, para poder decir
+ * dónde.
+ *
+ * `JSON.stringify` sobre una estructura cíclica dice "Converting circular
+ * structure to JSON" y no nombra la propiedad; sobre una función no dice nada,
+ * simplemente la omite. Las dos cosas son difíciles de diagnosticar en una
+ * página que dejó de hidratar.
+ *
+ * `Date` es la excepción deliberada: se convierte a su forma ISO y así llega al
+ * cliente. Es el comportamiento de siempre.
+ */
+function createGuard(root) {
+    const seen = new WeakSet();
+    const paths = new WeakMap();
+    return function guard(key, value) {
+        const parent = this;
+        const path = key === ''
+            ? root
+            : `${(parent && paths.get(parent)) ?? root}${/^\d+$/.test(key) ? `[${key}]` : `.${key}`}`;
+        const type = typeof value;
+        if (type === 'function')
+            throw new SerializationError('es una función', path);
+        if (type === 'bigint')
+            throw new SerializationError('es un BigInt', path);
+        if (type === 'symbol')
+            throw new SerializationError('es un Symbol', path);
+        if (value instanceof Map)
+            throw new SerializationError('es un Map', path);
+        if (value instanceof Set)
+            throw new SerializationError('es un Set', path);
+        if (value && type === 'object' && !(value instanceof Date)) {
+            if (seen.has(value)) {
+                throw new SerializationError('la estructura tiene un ciclo', path);
+            }
+            seen.add(value);
+            paths.set(value, path);
+        }
+        return value;
+    };
+}
+function describe(err) {
+    if (err instanceof SerializationError)
+        throw err;
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * El bloque `<script>` con el estado.
+ *
+ * Recibe el nonce cuando hay política de contenido: sin él, el bloque no se
+ * ejecuta y la hidratación no encuentra sus props.
+ */
+function renderStateScript(blocks, nonce) {
+    const attrs = nonce ? ` nonce="${(0, escape_1.escapeAttrValue)(nonce)}"` : '';
+    const body = blocks
+        .map((b) => `window.${b.varName}=${serializeState(b.value, '$.' + b.varName)};`)
+        .join('');
+    return `<script${attrs}>${body}</script>`;
+}
+/**
+ * Cuánto pesa el estado que viaja.
+ *
+ * Se mide sobre el string **ya serializado y escapado**, que es lo que
+ * efectivamente se transfiere, y en bytes y no en caracteres, porque un
+ * carácter fuera de ASCII ocupa más de uno.
+ */
+function checkStateSize(serialized, limitBytes, value) {
+    const bytes = Buffer.byteLength(serialized, 'utf8');
+    const overLimit = bytes > limitBytes;
+    const heaviest = overLimit && value && typeof value === 'object'
+        ? Object.entries(value)
+            .map(([key, v]) => ({ key, bytes: safeSize(v) }))
+            .sort((a, b) => b.bytes - a.bytes)
+            .slice(0, 3)
+        : [];
+    return { bytes, overLimit, heaviest };
+}
+function safeSize(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value) ?? '', 'utf8');
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/variants/assets.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import type { AssetIndex, VariantCatalog } from './types';
+/**
+ * Artefactos en desarrollo.
+ *
+ * Vite sirve el módulo virtual directamente, así que el guion es su propia URL.
+ * Los estilos no se listan porque el módulo los importa y Vite los inyecta.
+ */
+export declare function createDevAssetIndex(catalog: VariantCatalog, base?: string): AssetIndex;
+/** Forma del manifest que emite el entorno de cliente. */
+interface ManifestChunk {
+    file: string;
+    css?: string[];
+    name?: string;
+}
+/**
+ * Artefactos en producción, tomados del manifest del cliente.
+ *
+ * El manifest se lee una vez al arrancar y se pasa a un índice por página y
+ * variante, de modo que servir una petición sea una consulta en memoria y no una
+ * búsqueda.
+ */
+export declare function createProdAssetIndex(catalog: VariantCatalog, manifest: Record<string, ManifestChunk>, base?: string): AssetIndex;
+export {};