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

package/README.md

@@ -19,37 +19,47 @@ npm install @ressjs/vite-router
 - **🚀 Production Ready**: Optimized builds with manifest-based asset loading
 - **📝 TypeScript**: Full TypeScript support with comprehensive type definitions
 
+### Platform CSS and inline styles
+
+Style variants use the same filename convention for every supported format. The
+catalog and the inline components are provided by `@ressjs/assets`:
+
+```text
+app/pages/home/index.css
+app/pages/home/index.phone.css
+app/pages/home/index.webview.android.css
+```
+
+The matching stylesheet is selected from the detected platform. For CSS that is
+part of the rendered page, use the small `Style` component:
+
+```jsx
+import { Style } from '@ressjs/assets/client'
+
+export default function Home() {
+  return <><Style>{'.notice { color: red; }'}</Style><main className="notice">Hello</main></>
+}
+```
+
+`@ressjs/vite-router/client` remains a compatibility alias. `Script` is also
+available from `@ressjs/assets/client` for inline code or an explicit `src`.
+The router consumes `resolvePageAssets` from `@ressjs/assets`; request handling
+only reads the in-memory catalog and artifact index.
+
 ## Quick Start
 
 ### Vite Configuration
 
 Create a `vite.config.ts` file in your project root:
 
-```typescript
+```ts
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
-import { getClientEntriesInput, getViteSSRInput } from '@ressjs/vite-router'
-
-const isSSR = !!process.env.VITE_SSR_BUILD
+import { ressPlugin } from '@ressjs/vite-router/plugin'
 
-export default defineConfig(async () => ({
-  plugins: [react()],
-  server: {
-    watch: {
-      ignored: ['**/dist/.entries/**']  // Ignore generated entries
-    }
-  },
-  build: {
-    manifest: true,
-    outDir: isSSR ? 'dist/server' : 'dist/client',
-    rollupOptions: {
-      input: isSSR
-        ? getViteSSRInput()                    // SSR entry point
-        : await getClientEntriesInput(),      // Auto-generated client entries
-    },
-    ssr: isSSR,
-  },
-}))
+export default defineConfig({
+  plugins: [react(), ressPlugin()],
+})
 ```
 
 **Important**: The router automatically generates entry files for each page/platform combination in `dist/.entries/`. These are used by Vite for building client bundles.
@@ -113,10 +123,8 @@ Add these scripts to your `package.json`:
 {
   "scripts": {
     "dev": "node server.js",
-    "build": "npm run build:client && npm run build:server",
-    "build:client": "vite build",
-    "build:server": "VITE_SSR_BUILD=true vite build",
-    "preview": "NODE_ENV=production node server.js",
+    "build": "vite build",
+            "preview": "NODE_ENV=production node server.js",
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
@@ -146,10 +154,8 @@ For full-stack TypeScript projects with backend APIs, use this enhanced configur
   "type": "module",
   "scripts": {
     "dev": "PORT=3000 vite-node server.ts",
-    "build": "npm run build:client && npm run build:server",
-    "build:client": "vite build --outDir dist/client",
-    "build:server": "cross-env VITE_SSR_BUILD=1 vite build --ssr --outDir dist/server",
-    "preview": "cross-env NODE_ENV=production PORT=3000 tsx server.ts",
+    "build": "vite build",
+            "preview": "cross-env NODE_ENV=production PORT=3000 tsx server.ts",
     "start": "npm run build && npm run preview"
   },
   "dependencies": {
@@ -186,7 +192,7 @@ For full-stack TypeScript projects with backend APIs, use this enhanced configur
 - Require additional Express middleware and routes
 
 **Key Points**:
-- **`VITE_SSR_BUILD=true`**: Environment variable that tells Vite config to build for SSR
+- **Un solo `vite build`**: el plugin declara los entornos de cliente y servidor, y ambos se construyen en una sola invocación.
 - **Separate builds**: Client and server are built separately with different entry points
 - **Auto-generated entries**: `getClientEntriesInput()` discovers all page/platform combinations
 
@@ -529,3 +535,7 @@ app.listen(3000)
 ## 📄 License
 
 MIT
+
+### `index.html` opcional
+
+El router usa `index.html` del proyecto como shell cuando existe. Si no existe, usa una plantilla interna mínima con el contenedor `#root`; el SSR, los estilos y el entry cliente se inyectan igual. Mantener `index.html` permite personalizar el documento.

package/dist/client/entry.d.mts

@@ -0,0 +1,2 @@
+export { Script, Style } from '@ressjs/assets/client';
+export type { ScriptProps, StyleProps } from '@ressjs/assets/client';

package/dist/client/entry.mjs

@@ -0,0 +1 @@
+export { Script, Style } from '@ressjs/assets/client';

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export { Script, Style } from '@ressjs/assets';
+export type { ScriptProps, StyleProps } from '@ressjs/assets';

package/dist/client/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Style = exports.Script = void 0;
+// CJS compatibility entry. The ESM entrypoint is `entry.mts` and uses the
+// browser-oriented `@ressjs/assets/client` export.
+var assets_1 = require("@ressjs/assets");
+Object.defineProperty(exports, "Script", { enumerable: true, get: function () { return assets_1.Script; } });
+Object.defineProperty(exports, "Style", { enumerable: true, get: function () { return assets_1.Style; } });

package/dist/config/base-path.d.ts

@@ -0,0 +1,44 @@
+import type { TrailingSlashMode } from './types';
+/**
+ * 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.
+ */
+export declare function canonicalTrailingSlash(pathname: string, mode: TrailingSlashMode): string | undefined;
+/**
+ * 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.
+ */
+export declare function stripBasePath(pathname: string, basePath: string): string | 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.
+ */
+export declare function withBasePath(pathname: string, basePath: string): string;
+/**
+ * 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.
+ */
+export declare function assetPrefixFor(options: {
+    basePath: string;
+    cdnPrefix?: string;
+}): string;

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,23 @@
+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[]>;

package/dist/config/codegen.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlatformTypes = generatePlatformTypes;
+exports.generateProjectConfigTypes = generateProjectConfigTypes;
+exports.writeGeneratedTypes = writeGeneratedTypes;
+/**
+ * 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;
+}

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 } 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 } from './codegen';
+export { changedKeys, isConfigLayer, restartReason, watchConfig, HOT_KEYS, RESTART_REASONS } from './watch';
+export { validateConfig, validateRules } from './validate';
+export type { AssetsConfig, DevConfig, HeaderRule, ModeOverrides, PlatformConfig, RedirectRule, ResolvedConfig, RessConfig, RessServerConfig, RewriteRule, TrailingSlashMode, } from './types';

package/dist/config/index.js

@@ -0,0 +1,44 @@
+"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.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.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; } });
+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; } });
+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,26 @@
+import type { ResolvedConfig } 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`, `dev.hmr`, `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>;
+/** `'/app/'` y `'app'` describen lo mismo: se guardan como `'/app'`. */
+export declare function normalizeBasePath(basePath: string): string;