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

package/dist/config/base-path.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalTrailingSlash = canonicalTrailingSlash;
+exports.stripBasePath = stripBasePath;
+exports.withBasePath = withBasePath;
+exports.assetPrefixFor = assetPrefixFor;
+/**
+ * Prefijo de ruta y barra final.
+ *
+ * Las dos reglas describen la **misma URL escrita de distintas maneras**, así que
+ * se aplican antes que cualquier otra cosa del pipeline: a partir de ahí, el
+ * manifest de rutas, las redirecciones y las reescrituras ven una sola forma de
+ * cada petición y no tienen que contemplar variantes.
+ */
+/**
+ * La forma canónica de una ruta según la política de barra final, o `undefined`
+ * si ya lo es.
+ *
+ * Devolver `undefined` en vez de la misma cadena es lo que permite a quien llama
+ * distinguir «hay que redirigir» de «no hay nada que hacer» sin comparar strings.
+ */
+function canonicalTrailingSlash(pathname, mode) {
+    if (mode === 'ignore')
+        return undefined;
+    // La raíz es `/` en las dos políticas: no tiene una forma sin barra.
+    if (pathname === '/' || pathname === '')
+        return undefined;
+    const hasSlash = pathname.endsWith('/');
+    if (mode === 'never') {
+        if (!hasSlash)
+            return undefined;
+        const stripped = pathname.replace(/\/+$/, '');
+        return stripped === '' ? '/' : stripped;
+    }
+    if (hasSlash)
+        return undefined;
+    // Un último segmento con punto es un archivo —`/logo.svg`, `/robots.txt`—, y
+    // agregarle barra lo convierte en una ruta que no existe.
+    if (looksLikeFile(pathname))
+        return undefined;
+    return pathname + '/';
+}
+function looksLikeFile(pathname) {
+    const last = pathname.slice(pathname.lastIndexOf('/') + 1);
+    return last.includes('.');
+}
+/**
+ * Quita el prefijo de ruta.
+ *
+ * Devuelve `undefined` cuando la URL no cae bajo el prefijo: eso no es una ruta
+ * que esta aplicación atienda, y responder algo sería atender el sitio entero por
+ * dos direcciones distintas.
+ */
+function stripBasePath(pathname, basePath) {
+    if (!basePath)
+        return pathname;
+    if (pathname === basePath)
+        return '/';
+    if (pathname.startsWith(basePath + '/'))
+        return pathname.slice(basePath.length);
+    return undefined;
+}
+/**
+ * Antepone el prefijo a una ruta de la aplicación.
+ *
+ * Se usa para todo lo que el framework emite hacia el navegador —enlaces,
+ * artefactos, destinos de redirección—: una URL generada sin prefijo apunta
+ * afuera de la aplicación.
+ */
+function withBasePath(pathname, basePath) {
+    if (!basePath)
+        return pathname;
+    // Una URL absoluta —un CDN, otro dominio— ya dice dónde vive: no se le
+    // antepone nada.
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(pathname) || pathname.startsWith('//'))
+        return pathname;
+    if (!pathname.startsWith('/'))
+        return basePath + '/' + pathname;
+    if (pathname === '/')
+        return basePath + '/';
+    return basePath + pathname;
+}
+/**
+ * El prefijo con el que se sirven los artefactos.
+ *
+ * `assets.cdnPrefix` gana sobre el prefijo de ruta porque describe otro origen:
+ * cuando existe, los artefactos no salen de este servidor y el prefijo de ruta
+ * no les aplica.
+ */
+function assetPrefixFor(options) {
+    const prefix = options.cdnPrefix?.trim();
+    if (prefix)
+        return prefix.replace(/\/+$/, '') + '/';
+    // La raíz ya termina en `/`; agregar otra barra produce `//assets/...`,
+    // que el navegador interpreta como una URL de protocolo relativo hacia el
+    // host `assets` y deja fuera tanto el CSS como el entry de hidratación.
+    if (!options.basePath || options.basePath === '/')
+        return '/';
+    return options.basePath.replace(/\/+$/, '') + '/';
+}

package/dist/config/codegen.d.ts

@@ -0,0 +1,29 @@
+import type { PlatformConfig } from './types';
+/**
+ * Amplía `PlatformValueMap` de `@ressjs/platform` con los tokens del proyecto.
+ *
+ * Se agrupa por eje porque la interfaz tiene una clave por eje, y declararla dos
+ * veces con tipos distintos es un error de compilación.
+ */
+export declare function generatePlatformTypes(platform: PlatformConfig): string;
+/**
+ * Amplía `ProjectConfig` de `@ressjs/config` con la forma de los valores resueltos.
+ *
+ * Se infiere de lo que la resolución produjo y no del archivo fuente: es lo que
+ * el proyecto va a leer realmente, capas incluidas.
+ */
+export declare function generateProjectConfigTypes(values: Record<string, unknown>): string;
+/**
+ * Escribe los dos archivos si cambiaron.
+ *
+ * Compara antes de escribir porque el observador de desarrollo mira el sistema de
+ * archivos: reescribir el mismo contenido dispararía una recarga que a su vez
+ * volvería a generar, en un ciclo que no termina.
+ */
+export declare function writeGeneratedTypes(root: string, files: Record<string, string>): Promise<string[]>;
+/**
+ * Genera `types/` para un proyecto cuya configuración ya se cargó con
+ * `loadConfig`. La usan el plugin al arrancar y `ress info`, para que un
+ * proyecto recién creado o un clon limpio tengan sus tipos sin levantar nada.
+ */
+export declare function writeProjectTypes(root: string, platform: PlatformConfig): Promise<string[]>;

package/dist/config/codegen.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlatformTypes = generatePlatformTypes;
+exports.generateProjectConfigTypes = generateProjectConfigTypes;
+exports.writeGeneratedTypes = writeGeneratedTypes;
+exports.writeProjectTypes = writeProjectTypes;
+/**
+ * Tipos generados a partir de lo que el proyecto declara.
+ *
+ * Sin esto, declarar un token de plataforma propio en `ress.config.ts` funciona
+ * en tiempo de ejecución pero el editor no lo conoce: el desarrollador escribe
+ * `'kaios'` y no recibe ni sugerencia ni error si lo escribe mal. Los archivos se
+ * generan, no se versionan, y se rehacen cuando cambia la configuración que los
+ * origina.
+ */
+const BANNER = '// Generado por ress.js a partir de la configuración del proyecto.\n' +
+    '// No editar a mano ni versionar: se rehace en cada arranque.\n';
+/**
+ * Amplía `PlatformValueMap` de `@ressjs/platform` con los tokens del proyecto.
+ *
+ * Se agrupa por eje porque la interfaz tiene una clave por eje, y declararla dos
+ * veces con tipos distintos es un error de compilación.
+ */
+function generatePlatformTypes(platform) {
+    const byAxis = new Map();
+    for (const value of platform.values ?? []) {
+        if (!value?.token || !value?.axis)
+            continue;
+        const tokens = byAxis.get(value.axis) ?? [];
+        if (!tokens.includes(value.token))
+            tokens.push(value.token);
+        byAxis.set(value.axis, tokens);
+    }
+    if (byAxis.size === 0) {
+        // Un archivo vacío igual se escribe: si el proyecto quitó sus tokens, dejar
+        // el anterior mantendría en el autocompletado valores que ya no existen.
+        return BANNER + 'export {}\n';
+    }
+    const fields = [...byAxis.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([axis, tokens]) => `    ${axis}: ${tokens.map(quote).join(' | ')}`)
+        .join('\n');
+    return (BANNER +
+        "declare module '@ressjs/platform' {\n" +
+        '  interface PlatformValueMap {\n' +
+        fields +
+        '\n  }\n}\n\nexport {}\n');
+}
+/**
+ * Amplía `ProjectConfig` de `@ressjs/config` con la forma de los valores resueltos.
+ *
+ * Se infiere de lo que la resolución produjo y no del archivo fuente: es lo que
+ * el proyecto va a leer realmente, capas incluidas.
+ */
+function generateProjectConfigTypes(values) {
+    const keys = Object.keys(values).sort();
+    if (keys.length === 0)
+        return BANNER + 'export {}\n';
+    const fields = keys.map((key) => `    ${propertyName(key)}: ${typeOf(values[key])}`).join('\n');
+    return (BANNER +
+        "declare module '@ressjs/config' {\n" +
+        '  interface ProjectConfig {\n' +
+        fields +
+        '\n  }\n}\n\nexport {}\n');
+}
+/**
+ * El tipo de un valor, a un nivel de profundidad razonable.
+ *
+ * No se intenta reconstruir la forma exacta de una estructura anidada: el
+ * objetivo es autocompletar nombres de clave, y un tipo aproximado que se escribe
+ * en un archivo generado es mejor que uno exacto que nadie puede leer.
+ */
+function typeOf(value) {
+    if (value === null || value === undefined)
+        return 'unknown';
+    if (Array.isArray(value)) {
+        const inner = value.length ? typeOf(value[0]) : 'unknown';
+        return `${inner}[]`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (!entries.length)
+            return 'Record<string, unknown>';
+        return ('{ ' + entries.map(([k, v]) => `${propertyName(k)}: ${typeOf(v)}`).join('; ') + ' }');
+    }
+    if (typeof value === 'function')
+        return '(...args: never[]) => unknown';
+    return typeof value;
+}
+/** Una clave que no es un identificador válido va entre comillas. */
+function propertyName(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : quote(key);
+}
+function quote(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Escribe los dos archivos si cambiaron.
+ *
+ * Compara antes de escribir porque el observador de desarrollo mira el sistema de
+ * archivos: reescribir el mismo contenido dispararía una recarga que a su vez
+ * volvería a generar, en un ciclo que no termina.
+ */
+async function writeGeneratedTypes(root, files) {
+    const { writeFile, mkdir, readFile } = await import('node:fs/promises');
+    const path = await import('node:path');
+    const dir = path.join(root, 'types');
+    const written = [];
+    for (const [name, content] of Object.entries(files)) {
+        const target = path.join(dir, name);
+        const previous = await readFile(target, 'utf-8').catch(() => undefined);
+        if (previous === content)
+            continue;
+        await mkdir(dir, { recursive: true });
+        await writeFile(target, content, 'utf-8');
+        written.push(target);
+    }
+    return written;
+}
+/**
+ * Genera `types/` para un proyecto cuya configuración ya se cargó con
+ * `loadConfig`. La usan el plugin al arrancar y `ress info`, para que un
+ * proyecto recién creado o un clon limpio tengan sus tipos sin levantar nada.
+ */
+async function writeProjectTypes(root, platform) {
+    const { resolved } = await import('@ressjs/config');
+    return writeGeneratedTypes(root, {
+        'ress-platform.d.ts': generatePlatformTypes(platform),
+        'ress-config.d.ts': generateProjectConfigTypes(resolved()),
+    });
+}

package/dist/config/define.d.ts

@@ -0,0 +1,8 @@
+import type { RessConfig } from './types';
+/**
+ * Declara la configuración del framework.
+ *
+ * No transforma nada: existe para que el editor conozca la forma del objeto
+ * mientras se escribe, en vez de descubrir el error al arrancar.
+ */
+export declare function defineConfig(config: RessConfig): RessConfig;

package/dist/config/define.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = defineConfig;
+/**
+ * Declara la configuración del framework.
+ *
+ * No transforma nada: existe para que el editor conozca la forma del objeto
+ * mientras se escribe, en vez de descubrir el error al arrancar.
+ */
+function defineConfig(config) {
+    return config;
+}

package/dist/config/env.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Variables de entorno que llegan al navegador.
+ *
+ * Por lista explícita y nunca por prefijo. Un prefijo hace que agregar una
+ * variable la publique sin que nadie tome esa decisión, y el modo de fallo —una
+ * credencial dentro del paquete que se descarga— es grave y silencioso.
+ *
+ * El reemplazo es en tiempo de build: lo que no está declarado no queda como
+ * `undefined` en el navegador, queda como código que nunca se generó.
+ */
+export interface PublicEnvOptions {
+    /** De dónde se leen los valores. Se inyecta para poder probarlo. */
+    env?: Record<string, string | undefined>;
+    /** Si faltar una variable detiene el arranque. En build, sí. */
+    strict?: boolean;
+}
+export declare function publicEnvDefines(publicEnv: readonly string[], options?: PublicEnvOptions): Record<string, string>;
+/** Los valores publicados, para inspeccionarlos o serializarlos. */
+export declare function publicEnvValues(publicEnv: readonly string[], env?: Record<string, string | undefined>): Record<string, string>;

package/dist/config/env.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicEnvDefines = publicEnvDefines;
+exports.publicEnvValues = publicEnvValues;
+function publicEnvDefines(publicEnv, options = {}) {
+    const env = options.env ?? process.env;
+    const missing = [];
+    const defines = {};
+    for (const name of publicEnv) {
+        const value = env[name];
+        if (value === undefined) {
+            missing.push(name);
+            continue;
+        }
+        const literal = JSON.stringify(value);
+        // Las dos formas: el código de la aplicación suele escribir `process.env.X`
+        // por costumbre, y el de Vite `import.meta.env.X`. Reemplazar una sola deja
+        // la otra sin definir en el navegador, que es exactamente el error difícil
+        // de ver.
+        defines[`process.env.${name}`] = literal;
+        defines[`import.meta.env.${name}`] = literal;
+    }
+    if (missing.length && options.strict !== false) {
+        throw new Error(`[ress] \`publicEnv\` declara ${missing.length === 1 ? 'una variable que no existe' : 'variables que no existen'}: ` +
+            missing.join(', ') +
+            '. Exponer una variable inexistente es casi siempre un error de tipeo, y ' +
+            'el navegador recibiría el nombre sin valor.');
+    }
+    return defines;
+}
+/** Los valores publicados, para inspeccionarlos o serializarlos. */
+function publicEnvValues(publicEnv, env = process.env) {
+    const values = {};
+    for (const name of publicEnv) {
+        const value = env[name];
+        if (value !== undefined)
+            values[name] = value;
+    }
+    return values;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configuración del framework.
+ *
+ * `ress.config` declara el comportamiento; `@ressjs/config` declara los valores
+ * que cambian según dónde corre la aplicación. Son dos superficies distintas
+ * resueltas por el mismo motor, y sólo la primera la lee el router.
+ */
+export { loadConfig, normalizeBasePath, resolveIsrConfig } from './load';
+export { defineConfig } from './define';
+export { assetPrefixFor, canonicalTrailingSlash, stripBasePath, withBasePath, } from './base-path';
+export { applyParams, compileRules, matchRule, parseRulePattern } from './rules';
+export type { CompiledRule, CompiledRules } from './rules';
+export { createConfigMiddleware } from './middleware';
+export { publicEnvDefines, publicEnvValues } from './env';
+export { generateProjectConfigTypes, generatePlatformTypes, writeGeneratedTypes, writeProjectTypes } from './codegen';
+export { changedKeys, isConfigLayer, restartReason, watchConfig, HOT_KEYS, RESTART_REASONS } from './watch';
+export { validateConfig, validateRules } from './validate';
+export type { AssetsConfig, IsrConfig, ResolvedIsrConfig, HeaderRule, ModeOverrides, PlatformConfig, RedirectRule, ResolvedConfig, RessConfig, RessServerConfig, RewriteRule, TrailingSlashMode, } from './types';

package/dist/config/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Configuración del framework.
+ *
+ * `ress.config` declara el comportamiento; `@ressjs/config` declara los valores
+ * que cambian según dónde corre la aplicación. Son dos superficies distintas
+ * resueltas por el mismo motor, y sólo la primera la lee el router.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRules = exports.validateConfig = exports.RESTART_REASONS = exports.HOT_KEYS = exports.watchConfig = exports.restartReason = exports.isConfigLayer = exports.changedKeys = exports.writeProjectTypes = exports.writeGeneratedTypes = exports.generatePlatformTypes = exports.generateProjectConfigTypes = exports.publicEnvValues = exports.publicEnvDefines = exports.createConfigMiddleware = exports.parseRulePattern = exports.matchRule = exports.compileRules = exports.applyParams = exports.withBasePath = exports.stripBasePath = exports.canonicalTrailingSlash = exports.assetPrefixFor = exports.defineConfig = exports.resolveIsrConfig = exports.normalizeBasePath = exports.loadConfig = void 0;
+var load_1 = require("./load");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_1.loadConfig; } });
+Object.defineProperty(exports, "normalizeBasePath", { enumerable: true, get: function () { return load_1.normalizeBasePath; } });
+Object.defineProperty(exports, "resolveIsrConfig", { enumerable: true, get: function () { return load_1.resolveIsrConfig; } });
+var define_1 = require("./define");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return define_1.defineConfig; } });
+var base_path_1 = require("./base-path");
+Object.defineProperty(exports, "assetPrefixFor", { enumerable: true, get: function () { return base_path_1.assetPrefixFor; } });
+Object.defineProperty(exports, "canonicalTrailingSlash", { enumerable: true, get: function () { return base_path_1.canonicalTrailingSlash; } });
+Object.defineProperty(exports, "stripBasePath", { enumerable: true, get: function () { return base_path_1.stripBasePath; } });
+Object.defineProperty(exports, "withBasePath", { enumerable: true, get: function () { return base_path_1.withBasePath; } });
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "applyParams", { enumerable: true, get: function () { return rules_1.applyParams; } });
+Object.defineProperty(exports, "compileRules", { enumerable: true, get: function () { return rules_1.compileRules; } });
+Object.defineProperty(exports, "matchRule", { enumerable: true, get: function () { return rules_1.matchRule; } });
+Object.defineProperty(exports, "parseRulePattern", { enumerable: true, get: function () { return rules_1.parseRulePattern; } });
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "createConfigMiddleware", { enumerable: true, get: function () { return middleware_1.createConfigMiddleware; } });
+var env_1 = require("./env");
+Object.defineProperty(exports, "publicEnvDefines", { enumerable: true, get: function () { return env_1.publicEnvDefines; } });
+Object.defineProperty(exports, "publicEnvValues", { enumerable: true, get: function () { return env_1.publicEnvValues; } });
+var codegen_1 = require("./codegen");
+Object.defineProperty(exports, "generateProjectConfigTypes", { enumerable: true, get: function () { return codegen_1.generateProjectConfigTypes; } });
+Object.defineProperty(exports, "generatePlatformTypes", { enumerable: true, get: function () { return codegen_1.generatePlatformTypes; } });
+Object.defineProperty(exports, "writeGeneratedTypes", { enumerable: true, get: function () { return codegen_1.writeGeneratedTypes; } });
+Object.defineProperty(exports, "writeProjectTypes", { enumerable: true, get: function () { return codegen_1.writeProjectTypes; } });
+var watch_1 = require("./watch");
+Object.defineProperty(exports, "changedKeys", { enumerable: true, get: function () { return watch_1.changedKeys; } });
+Object.defineProperty(exports, "isConfigLayer", { enumerable: true, get: function () { return watch_1.isConfigLayer; } });
+Object.defineProperty(exports, "restartReason", { enumerable: true, get: function () { return watch_1.restartReason; } });
+Object.defineProperty(exports, "watchConfig", { enumerable: true, get: function () { return watch_1.watchConfig; } });
+Object.defineProperty(exports, "HOT_KEYS", { enumerable: true, get: function () { return watch_1.HOT_KEYS; } });
+Object.defineProperty(exports, "RESTART_REASONS", { enumerable: true, get: function () { return watch_1.RESTART_REASONS; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return validate_1.validateConfig; } });
+Object.defineProperty(exports, "validateRules", { enumerable: true, get: function () { return validate_1.validateRules; } });

package/dist/config/load.d.ts

@@ -0,0 +1,28 @@
+import type { IsrConfig, ResolvedConfig, ResolvedIsrConfig } from './types';
+/**
+ * Lee la configuración del proyecto y la deja lista para consultar.
+ *
+ * **Una sola superficie**: la carpeta `config/`, con un archivo por modo.
+ *
+ * ```
+ * config/default.js       ← lo común, opcional
+ * config/development.js
+ * config/production.js
+ * config/test.js
+ * config/local.js         ← esta máquina; no se sube
+ * ```
+ *
+ * Cada archivo exporta por defecto un objeto con **todo**: `basePath`,
+ * `redirects`, `publicEnv`, `security`, y también los valores propios
+ * del proyecto —la URL de una API, una clave—. Se fusionan `default` → el modo
+ * activo → `local`, y la última capa que declara una clave gana.
+ *
+ * Antes esto estaban partido en dos archivos distintos, `ress.config` para el
+ * comportamiento y `config/` para los valores. Eran dos lugares donde buscar la
+ * misma respuesta —"¿de dónde sale este valor?"— y dos formas de declararla.
+ */
+export declare function loadConfig(root?: string, mode?: string): Promise<ResolvedConfig>;
+/** Los valores por defecto de la caché incremental, en un solo lugar. */
+export declare function resolveIsrConfig(declared?: IsrConfig): ResolvedIsrConfig;
+/** `'/app/'` y `'app'` describen lo mismo: se guardan como `'/app'`. */
+export declare function normalizeBasePath(basePath: string): string;

package/dist/config/load.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.resolveIsrConfig = resolveIsrConfig;
+exports.normalizeBasePath = normalizeBasePath;
+const config_1 = require("@ressjs/config");
+const validate_1 = require("./validate");
+/**
+ * Lee la configuración del proyecto y la deja lista para consultar.
+ *
+ * **Una sola superficie**: la carpeta `config/`, con un archivo por modo.
+ *
+ * ```
+ * config/default.js       ← lo común, opcional
+ * config/development.js
+ * config/production.js
+ * config/test.js
+ * config/local.js         ← esta máquina; no se sube
+ * ```
+ *
+ * Cada archivo exporta por defecto un objeto con **todo**: `basePath`,
+ * `redirects`, `publicEnv`, `security`, y también los valores propios
+ * del proyecto —la URL de una API, una clave—. Se fusionan `default` → el modo
+ * activo → `local`, y la última capa que declara una clave gana.
+ *
+ * Antes esto estaban partido en dos archivos distintos, `ress.config` para el
+ * comportamiento y `config/` para los valores. Eran dos lugares donde buscar la
+ * misma respuesta —"¿de dónde sale este valor?"— y dos formas de declararla.
+ */
+async function loadConfig(root = process.cwd(), mode = process.env.NODE_ENV === 'production' ? 'production' : 'development') {
+    // La misma resolución que lee el código de la aplicación con
+    // `import { config } from '@ressjs/config'`: un solo objeto, resuelto una vez.
+    const declared = (await (0, config_1.resolveConfig)(root, mode));
+    (0, validate_1.validateConfig)(declared);
+    return resolve(declared);
+}
+/**
+ * Completa lo que el proyecto no declaró.
+ *
+ * Se hace una vez al arrancar y no por consulta: así el resto del framework lee
+ * `config.security` sin `?.` ni `??` en cada uso, y los valores por defecto están
+ * escritos en un solo lugar.
+ */
+async function resolve(declared) {
+    return {
+        // Sin barra final: se agrega al componer, y tenerla en el valor guardado
+        // obliga a recordar si ya está en cada concatenación.
+        basePath: normalizeBasePath(declared.basePath ?? ''),
+        trailingSlash: declared.trailingSlash ?? 'ignore',
+        // Las tres son funciones para que el proyecto pueda leer un archivo o
+        // consultar algo al arrancar. Se invocan una vez, acá.
+        redirects: (await declared.redirects?.()) ?? [],
+        rewrites: (await declared.rewrites?.()) ?? [],
+        headers: (await declared.headers?.()) ?? [],
+        publicEnv: declared.publicEnv ?? [],
+        extensions: declared.extensions ?? {},
+        platform: declared.platform ?? {},
+        security: declared.security ?? {},
+        assets: declared.assets ?? {},
+        isr: resolveIsrConfig(declared.isr),
+        server: declared.server ?? {},
+    };
+}
+/** Los valores por defecto de la caché incremental, en un solo lugar. */
+function resolveIsrConfig(declared = {}) {
+    return {
+        maxEntries: declared.maxEntries ?? 500,
+        maxBytes: declared.maxBytes ?? 50 * 1024 * 1024,
+        generationTimeoutMs: declared.generationTimeoutMs ?? 30_000,
+        dev: declared.dev ?? false,
+        sharedCache: declared.sharedCache ?? 'auto',
+        ...(declared.previewSecret !== undefined ? { previewSecret: declared.previewSecret } : {}),
+    };
+}
+/** `'/app/'` y `'app'` describen lo mismo: se guardan como `'/app'`. */
+function normalizeBasePath(basePath) {
+    const trimmed = basePath.trim();
+    if (!trimmed || trimmed === '/')
+        return '';
+    const withLeading = trimmed.startsWith('/') ? trimmed : '/' + trimmed;
+    return withLeading.replace(/\/+$/, '');
+}

package/dist/config/middleware.d.ts

@@ -0,0 +1,18 @@
+import { type CompiledRules } from './rules';
+import type { ResolvedConfig } from './types';
+/**
+ * Lo que la configuración aporta al pipeline de petición.
+ *
+ * El orden es fijo y está en el plan:
+ *
+ * 1. barra final — para que todo lo que sigue vea una sola forma de cada URL
+ * 2. prefijo de ruta — para que el manifest trabaje siempre sin prefijo
+ * 3. redirecciones — si alguna coincide, se responde y se termina
+ * 4. reescrituras — cambian la ruta a resolver, no la que el navegador muestra
+ * 5. cabeceras — al escribir la respuesta, sin pisar las del framework
+ */
+export interface ConfigMiddlewareOptions {
+    /** Reglas ya compiladas. Se compilan una vez al arrancar, no por petición. */
+    compiled?: CompiledRules;
+}
+export declare function createConfigMiddleware(config: ResolvedConfig, options?: ConfigMiddlewareOptions): (req: any, res: any, next: (err?: unknown) => void) => void;

package/dist/config/middleware.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigMiddleware = createConfigMiddleware;
+const base_path_1 = require("./base-path");
+const rules_1 = require("./rules");
+function createConfigMiddleware(config, options = {}) {
+    const rules = options.compiled ?? (0, rules_1.compileRules)(config);
+    const { basePath, trailingSlash } = config;
+    return function configMiddleware(req, res, next) {
+        const url = req.url ?? '/';
+        const cut = url.search(/[?#]/);
+        const pathname = cut === -1 ? url : url.slice(0, cut);
+        const suffix = cut === -1 ? '' : url.slice(cut);
+        const canonical = (0, base_path_1.canonicalTrailingSlash)(pathname, trailingSlash);
+        if (canonical !== undefined) {
+            // 308: el navegador y los intermediarios tienen que conservar el método.
+            // Un 301 convierte un POST en GET al repetir.
+            return redirect(res, 308, canonical + suffix);
+        }
+        const inner = (0, base_path_1.stripBasePath)(pathname, basePath);
+        if (inner === undefined) {
+            // Fuera del prefijo no hay aplicación: se marca para que ni los artefactos
+            // ni las páginas la atiendan. Sin la marca, declarar un prefijo dejaba el
+            // sitio servido por dos direcciones distintas a la vez, que es justo lo
+            // que un prefijo existe para evitar.
+            req.ressOutsideBasePath = true;
+            return next();
+        }
+        // La URL original queda a mano: los mensajes de error y los enlaces
+        // canónicos hablan de lo que el navegador pidió, no de lo que quedó
+        // después de quitar el prefijo.
+        req.ressOriginalUrl ??= url;
+        req.ressBasePath = basePath;
+        req.url = inner + suffix;
+        const redirection = (0, rules_1.matchRule)(rules.redirects, inner);
+        if (redirection) {
+            const target = (0, rules_1.applyParams)(redirection.compiled.rule.destination, redirection.params);
+            return redirect(res, redirection.compiled.rule.permanent ? 308 : 307, absolute(target) ? target : (0, base_path_1.withBasePath)(target, basePath) + suffix);
+        }
+        const rewrite = (0, rules_1.matchRule)(rules.rewrites, inner);
+        if (rewrite) {
+            // Sólo cambia lo que el servidor resuelve: `req.url` es interno, y la
+            // barra de direcciones del navegador no se entera.
+            req.url = (0, rules_1.applyParams)(rewrite.compiled.rule.destination, rewrite.params) + suffix;
+        }
+        applyHeaderRules(rules, inner, res);
+        next();
+    };
+}
+function absolute(target) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(target) || target.startsWith('//');
+}
+function redirect(res, status, location) {
+    res.statusCode = status;
+    res.setHeader('Location', location);
+    res.end();
+}
+/**
+ * Las cabeceras declaradas se escriben al enviar, no ahora.
+ *
+ * Ponerlas ya las dejaría expuestas a que el framework las pisara después; y
+ * ponerlas después de las suyas es justamente la regla: complementan lo que el
+ * framework decidió, no lo corrigen. Por eso sólo se escribe lo que nadie fijó.
+ */
+function applyHeaderRules(rules, pathname, res) {
+    const match = (0, rules_1.matchRule)(rules.headers, pathname);
+    if (!match)
+        return;
+    const write = res.writeHead?.bind(res);
+    if (!write)
+        return;
+    res.writeHead = (...args) => {
+        for (const { key, value } of match.compiled.rule.headers) {
+            if (res.getHeader?.(key) === undefined)
+                res.setHeader(key, value);
+        }
+        return write(...args);
+    };
+}