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

package/dist/config/watch.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANUAL_RESTART_KEYS = exports.RESTART_REASONS = exports.HOT_KEYS = void 0;
+exports.changedKeys = changedKeys;
+exports.manualRestartReason = manualRestartReason;
+exports.restartReason = restartReason;
+exports.isConfigLayer = isConfigLayer;
+exports.watchConfig = watchConfig;
+const config_1 = require("@ressjs/config");
+const load_1 = require("./load");
+/**
+ * Recarga de la configuración en desarrollo.
+ *
+ * Se observa la carpeta `config/`: cualquiera de sus capas, no sólo la del modo
+ * activo, porque `default` y `local` también participan de la fusión.
+ */
+/**
+ * Claves que se pueden aplicar sin reiniciar.
+ *
+ * Todas se consultan al atender una petición, así que la siguiente ya ve el
+ * valor nuevo.
+ */
+// `security` no está acá: `createViteRouter`/`ressCorePlugin` la resuelven una
+// sola vez, dentro de `setup()`/el hook `config`, así que un cambio en caliente
+// de `config/*.js` no la vuelve a completar. Está en `RESTART_REASONS`.
+exports.HOT_KEYS = ['redirects', 'rewrites', 'headers', 'trailingSlash'];
+/**
+ * Claves que exigen reiniciar, y por qué.
+ *
+ * El framework lo dice nombrando la clave en vez de aplicar la mitad de la
+ * configuración: media configuración aplicada es un estado que nadie declaró y
+ * que produce errores que no se corresponden con ningún archivo.
+ */
+exports.RESTART_REASONS = {
+    basePath: 'cambia la URL bajo la que se sirve todo, incluidos los artefactos ya emitidos',
+    extensions: 'cambia qué archivos son páginas, y eso redefine el catálogo de entradas',
+    platform: 'redefine los ejes de plataforma, y con ellos las variantes que se construyen',
+    publicEnv: 'las variables se reemplazan en tiempo de build, no al atender una petición',
+    assets: 'el índice de artefactos se arma una vez, con el prefijo vigente al arrancar',
+    security: 'las cabeceras, la política de contenido y los límites se resuelven una vez al armar el router',
+    isr: 'la caché incremental se crea una vez, con sus límites y su secreto de vista previa',
+    // F-033: `beforeRouter`/`afterRouter` se montan una vez, al construir la
+    // aplicación de servidor. Tratar su cambio como aplicable en caliente
+    // dejaría un "recargado" en el log sin ningún efecto real.
+    server: 'los middlewares de la vía de escape se montan una sola vez, al construir el servidor',
+};
+/**
+ * Claves que se leen al construir la aplicación de servidor de ress —el
+ * router, la caché incremental, los middlewares de la vía de escape—, no el
+ * servidor de Vite.
+ *
+ * Reiniciar Vite no las aplica: la CLI arma esa aplicación una sola vez, fuera
+ * de Vite. Para ellas no se reinicia nada ni se dice que se reinició: se pide
+ * detener y volver a arrancar `ress dev`.
+ */
+exports.MANUAL_RESTART_KEYS = new Set([
+    'basePath',
+    'assets',
+    'security',
+    'isr',
+    'server',
+]);
+/** Qué claves de primer nivel cambiaron entre dos configuraciones resueltas. */
+function changedKeys(previous, next) {
+    const keys = new Set([...Object.keys(previous), ...Object.keys(next)]);
+    const changed = [];
+    for (const key of keys) {
+        const a = stable(previous[key]);
+        const b = stable(next[key]);
+        if (a !== b)
+            changed.push(key);
+    }
+    return changed.sort();
+}
+/**
+ * Serialización estable para comparar.
+ *
+ * Las claves de un objeto se ordenan: dos configuraciones equivalentes escritas
+ * en distinto orden no son un cambio, y tratarlas como tal reiniciaría el
+ * servidor por nada.
+ */
+function stable(value) {
+    if (typeof value === 'function')
+        return `fn:${String(value)}`;
+    if (value === undefined)
+        return 'undefined';
+    return JSON.stringify(value, (_key, inner) => {
+        if (typeof inner === 'function')
+            return `fn:${String(inner)}`;
+        if (inner && typeof inner === 'object' && !Array.isArray(inner)) {
+            return Object.fromEntries(Object.entries(inner).sort(([a], [b]) => a.localeCompare(b)));
+        }
+        return inner;
+    });
+}
+/** Si alguna de las claves cambiadas exige volver a arrancar `ress dev` a mano. */
+function manualRestartReason(changed) {
+    for (const key of changed) {
+        if (exports.MANUAL_RESTART_KEYS.has(key))
+            return `\`${key}\`: ${exports.RESTART_REASONS[key]}`;
+    }
+    return undefined;
+}
+/** El motivo del reinicio, o nada si todo lo que cambió se aplica en caliente. */
+function restartReason(changed) {
+    for (const key of changed) {
+        const reason = exports.RESTART_REASONS[key];
+        if (reason)
+            return `\`${key}\`: ${reason}`;
+    }
+    return undefined;
+}
+/** ¿Este archivo es una capa de configuración del proyecto? */
+function isConfigLayer(file, root) {
+    const normalized = file.replace(/\\/g, '/');
+    const base = root.replace(/\\/g, '/').replace(/\/+$/, '');
+    if (!normalized.startsWith(base + '/'))
+        return false;
+    const relative = normalized.slice(base.length + 1);
+    return /^config\/[^/]+$/.test(relative) || /^config\.[^/]+$/.test(relative);
+}
+/** Conecta el observador de Vite con la carpeta de configuración. */
+function watchConfig(server, options) {
+    const log = options.log ?? ((message) => console.log(message));
+    const restart = options.onRestart ??
+        ((reason) => {
+            log(`[ress] Reiniciando: ${reason}`);
+            void server?.restart?.();
+        });
+    const onChange = async (file) => {
+        if (!isConfigLayer(file, options.root))
+            return;
+        // Lo resuelto se descarta entero: la fusión depende de todas las capas, así
+        // que un cambio en cualquiera de ellas invalida el resultado.
+        (0, config_1.invalidateConfig)();
+        let next;
+        try {
+            next = await (0, load_1.loadConfig)(options.root, options.mode);
+        }
+        catch (error) {
+            // Un archivo a medio escribir no tiene que voltear el servidor: se informa
+            // y se sigue con la configuración anterior hasta que vuelva a guardarse.
+            log(`[ress] La configuración no se pudo cargar: ${error.message}`);
+            return;
+        }
+        const changed = changedKeys(options.current(), next);
+        if (changed.length === 0)
+            return;
+        // Lo que no aplica ni Vite: se dice qué hacer en vez de fingir un reinicio.
+        const manual = manualRestartReason(changed);
+        if (manual) {
+            return log(`[ress] Cambió ${manual}. Detené y volvé a arrancar \`ress dev\` para aplicarlo.`);
+        }
+        const reason = restartReason(changed);
+        if (reason)
+            return restart(reason);
+        options.onReload(next);
+        log(`[ress] Configuración recargada: ${changed.join(', ')}`);
+    };
+    for (const event of ['add', 'change', 'unlink']) {
+        server?.watcher?.on(event, (file) => void onChange(file));
+    }
+}

package/dist/fs/module-extensions.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Qué extensiones acepta el framework, declarado una sola vez.
+ *
+ * Antes cada punto del pipeline tenía su propia idea: el descubrimiento globeaba
+ * `.tsx` y `.jsx`, el render exigía `.tsx` y lanzaba con cualquier otra cosa, y
+ * la carga en producción ramificaba por extensión. El resultado era que un
+ * proyecto en JavaScript descubría sus páginas y reventaba al renderizarlas.
+ *
+ * Ninguna función de este módulo toca el sistema de archivos: son puras sobre
+ * cadenas, y por eso se pueden probar sin montar un proyecto.
+ */
+export declare const SCRIPT_EXTENSIONS: readonly [".tsx", ".ts", ".jsx", ".js"];
+export type ScriptExtension = (typeof SCRIPT_EXTENSIONS)[number];
+export interface ExtensionPolicy {
+    /** Extensiones válidas para un archivo de página. */
+    page: readonly ScriptExtension[];
+    /** Extensiones válidas para un archivo de middleware. */
+    middleware: readonly ScriptExtension[];
+    /** Extensión que produce el build. Siempre una sola. */
+    compiled: '.js';
+    /** Sufijos que se ignoran aunque la extensión coincida. */
+    ignoredSuffixes: readonly string[];
+}
+export declare const DEFAULT_EXTENSION_POLICY: ExtensionPolicy;
+export interface PageExclusion {
+    /** Identifica la convención que reservó el nombre, para diagnósticos. */
+    owner: string;
+    /** Se evalúa sobre la ruta relativa a pages, sin extensión. */
+    matches(relativePath: string): boolean;
+}
+/**
+ * Convenciones de archivos que pueden vivir bajo `app/pages` sin ser páginas.
+ *
+ * Este es el único registro: tanto el descubrimiento legado como el manifest
+ * consultan `isPageFile`, de modo que ampliar las extensiones no convierte un
+ * middleware, test o auxiliar en una ruta accidental.
+ */
+export declare const DEFAULT_EXCLUSIONS: readonly PageExclusion[];
+/** `['.tsx','.ts']` → `{tsx,ts}`, la forma que entiende un glob. */
+export declare function globBrace(extensions: readonly ScriptExtension[]): string;
+export declare function pageGlob(policy: ExtensionPolicy, pagesDir?: string): string;
+export declare function middlewareGlobs(policy: ExtensionPolicy, pagesDir?: string): string[];
+/**
+ * La extensión de un archivo, si es una de las que el framework reconoce.
+ *
+ * Se compara en minúsculas: en macOS y Windows un `Index.TSX` es el mismo
+ * archivo, y rechazarlo por la capitalización sería un fallo incomprensible.
+ */
+export declare function scriptExtensionOf(file: string): ScriptExtension | undefined;
+export declare function isIgnoredModule(file: string, policy?: ExtensionPolicy): boolean;
+/**
+ * El archivo sin su extensión.
+ *
+ * Lanza en vez de devolver el path intacto: un archivo que llegó hasta acá sin
+ * una extensión reconocida es un error de configuración, y devolverlo tal cual
+ * lo convertiría en un fallo más adelante y más difícil de ubicar.
+ */
+export declare function stripScriptExtension(file: string): string;
+/**
+ * Archivos que viven junto a las páginas sin ser una.
+ *
+ * Hace falta desde que la política acepta `.ts` y `.js`: un archivo suelto ahí
+ * es casi siempre un ayudante —un cliente de API, un tipo compartido, un test— y
+ * tomarlo por una ruta produce una URL que existe y falla al renderizar, porque
+ * no exporta ningún componente.
+ */
+export declare function pageExclusionOf(file: string, pagesDir?: string, exclusions?: readonly PageExclusion[]): PageExclusion | undefined;
+export declare function isPageFile(file: string, policy?: ExtensionPolicy, pagesDir?: string, exclusions?: readonly PageExclusion[]): boolean;
+/**
+ * La ruta que un archivo de middleware protege.
+ *
+ * `pokedex/middlewares.tsx` protege `/pokedex`; `home/index.middlewares.js`
+ * protege `/home/index`. Antes esto se derivaba con una expresión que sólo
+ * recortaba `.ts` y `.js`, así que un middleware `.tsx` producía una ruta con la
+ * extensión adentro y no coincidía con ninguna página: no corría, y sin aviso.
+ */
+export declare function middlewareRoute(file: string, pagesDir?: string): string;
+export declare function isMiddlewareFile(file: string, policy?: ExtensionPolicy): boolean;
+/**
+ * Identificador de una página, sin su extensión ni el prefijo del directorio.
+ *
+ * Es la clave que comparten el catálogo de variantes y el manifest de rutas, así
+ * que dos archivos que sólo difieren en la extensión producen el mismo: es lo
+ * que permite detectar que ambos existen.
+ */
+export declare function pageIdOf(file: string, pagesDir?: string): string;
+/**
+ * Dónde queda un módulo después de compilarse.
+ *
+ * El build emite siempre `.js`, cualquiera sea la extensión de origen, y sanea
+ * los corchetes de los parámetros porque no pueden formar parte de un nombre de
+ * archivo en todos los sistemas.
+ */
+export declare function toCompiledPath(file: string, policy?: ExtensionPolicy, pagesDir?: string): string;
+/**
+ * Dos archivos que producen la misma página son ambiguos.
+ *
+ * Cuál gana dependería del orden en que el sistema de archivos los devolvió, y
+ * ese orden cambia entre sistemas. Mejor fallar al arrancar nombrando los dos.
+ */
+export declare function assertNoModuleCollision(files: readonly string[], pagesDir?: string, options?: {
+    strict?: boolean;
+}): void;
+export declare function setExtensionPolicy(policy: ExtensionPolicy): void;
+export declare function getExtensionPolicy(): ExtensionPolicy;

package/dist/fs/module-extensions.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Qué extensiones acepta el framework, declarado una sola vez.
+ *
+ * Antes cada punto del pipeline tenía su propia idea: el descubrimiento globeaba
+ * `.tsx` y `.jsx`, el render exigía `.tsx` y lanzaba con cualquier otra cosa, y
+ * la carga en producción ramificaba por extensión. El resultado era que un
+ * proyecto en JavaScript descubría sus páginas y reventaba al renderizarlas.
+ *
+ * Ninguna función de este módulo toca el sistema de archivos: son puras sobre
+ * cadenas, y por eso se pueden probar sin montar un proyecto.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXCLUSIONS = exports.DEFAULT_EXTENSION_POLICY = exports.SCRIPT_EXTENSIONS = void 0;
+exports.globBrace = globBrace;
+exports.pageGlob = pageGlob;
+exports.middlewareGlobs = middlewareGlobs;
+exports.scriptExtensionOf = scriptExtensionOf;
+exports.isIgnoredModule = isIgnoredModule;
+exports.stripScriptExtension = stripScriptExtension;
+exports.pageExclusionOf = pageExclusionOf;
+exports.isPageFile = isPageFile;
+exports.middlewareRoute = middlewareRoute;
+exports.isMiddlewareFile = isMiddlewareFile;
+exports.pageIdOf = pageIdOf;
+exports.toCompiledPath = toCompiledPath;
+exports.assertNoModuleCollision = assertNoModuleCollision;
+exports.setExtensionPolicy = setExtensionPolicy;
+exports.getExtensionPolicy = getExtensionPolicy;
+exports.SCRIPT_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js'];
+exports.DEFAULT_EXTENSION_POLICY = {
+    page: exports.SCRIPT_EXTENSIONS,
+    middleware: exports.SCRIPT_EXTENSIONS,
+    compiled: '.js',
+    // Un `.d.ts` declara tipos: nunca es un módulo que se pueda ejecutar.
+    ignoredSuffixes: ['.d.ts'],
+};
+/**
+ * Convenciones de archivos que pueden vivir bajo `app/pages` sin ser páginas.
+ *
+ * Este es el único registro: tanto el descubrimiento legado como el manifest
+ * consultan `isPageFile`, de modo que ampliar las extensiones no convierte un
+ * middleware, test o auxiliar en una ruta accidental.
+ */
+exports.DEFAULT_EXCLUSIONS = [
+    { owner: 'middlewares', matches: (relative) => /(^|\/)middlewares$/.test(relative) },
+    { owner: 'middlewares', matches: (relative) => /\.middlewares$/.test(relative) },
+    { owner: 'auxiliar', matches: (relative) => /(^|\/)_[^/]*/.test(relative) },
+    { owner: 'test', matches: (relative) => /\.(?:test|spec)$/.test(relative) },
+];
+/** `['.tsx','.ts']` → `{tsx,ts}`, la forma que entiende un glob. */
+function globBrace(extensions) {
+    if (extensions.length === 0) {
+        throw new Error('[ress] La política de extensiones quedó vacía. ' +
+            `Declará al menos una de: ${exports.SCRIPT_EXTENSIONS.join(', ')}.`);
+    }
+    const bare = extensions.map((e) => e.slice(1));
+    return bare.length === 1 ? bare[0] : `{${bare.join(',')}}`;
+}
+function pageGlob(policy, pagesDir = 'app/pages') {
+    return `${pagesDir.replace(/\\/g, '/')}/**/*.${globBrace(policy.page)}`;
+}
+function middlewareGlobs(policy, pagesDir = 'app/pages') {
+    const ext = globBrace(policy.middleware);
+    const normalizedPagesDir = pagesDir.replace(/\\/g, '/');
+    return [`${normalizedPagesDir}/**/middlewares.${ext}`, `${normalizedPagesDir}/**/*.middlewares.${ext}`];
+}
+/**
+ * La extensión de un archivo, si es una de las que el framework reconoce.
+ *
+ * Se compara en minúsculas: en macOS y Windows un `Index.TSX` es el mismo
+ * archivo, y rechazarlo por la capitalización sería un fallo incomprensible.
+ */
+function scriptExtensionOf(file) {
+    const lower = file.toLowerCase();
+    // De más larga a más corta: `.tsx` termina en `x`, no en `.ts`, pero el orden
+    // deja explícito que la comparación no es ambigua.
+    return exports.SCRIPT_EXTENSIONS.find((ext) => lower.endsWith(ext));
+}
+function isIgnoredModule(file, policy = exports.DEFAULT_EXTENSION_POLICY) {
+    const lower = file.toLowerCase();
+    return policy.ignoredSuffixes.some((suffix) => lower.endsWith(suffix.toLowerCase()));
+}
+/**
+ * El archivo sin su extensión.
+ *
+ * Lanza en vez de devolver el path intacto: un archivo que llegó hasta acá sin
+ * una extensión reconocida es un error de configuración, y devolverlo tal cual
+ * lo convertiría en un fallo más adelante y más difícil de ubicar.
+ */
+function stripScriptExtension(file) {
+    const ext = scriptExtensionOf(file);
+    if (!ext) {
+        throw new Error(`[ress] "${file}" no tiene una extensión que el framework reconozca. ` +
+            `Válidas: ${exports.SCRIPT_EXTENSIONS.join(', ')}.`);
+    }
+    return file.slice(0, -ext.length);
+}
+/**
+ * Archivos que viven junto a las páginas sin ser una.
+ *
+ * Hace falta desde que la política acepta `.ts` y `.js`: un archivo suelto ahí
+ * es casi siempre un ayudante —un cliente de API, un tipo compartido, un test— y
+ * tomarlo por una ruta produce una URL que existe y falla al renderizar, porque
+ * no exporta ningún componente.
+ */
+function pageExclusionOf(file, pagesDir = 'app/pages', exclusions = exports.DEFAULT_EXCLUSIONS) {
+    const relative = stripScriptExtension(relativeToPages(file, pagesDir));
+    return exclusions.find((exclusion) => exclusion.matches(relative));
+}
+function isPageFile(file, policy = exports.DEFAULT_EXTENSION_POLICY, pagesDir = 'app/pages', exclusions = exports.DEFAULT_EXCLUSIONS) {
+    if (isIgnoredModule(file, policy))
+        return false;
+    const ext = scriptExtensionOf(file);
+    if (!ext || !policy.page.includes(ext))
+        return false;
+    return pageExclusionOf(file, pagesDir, exclusions) === undefined;
+}
+/**
+ * La ruta que un archivo de middleware protege.
+ *
+ * `pokedex/middlewares.tsx` protege `/pokedex`; `home/index.middlewares.js`
+ * protege `/home/index`. Antes esto se derivaba con una expresión que sólo
+ * recortaba `.ts` y `.js`, así que un middleware `.tsx` producía una ruta con la
+ * extensión adentro y no coincidía con ninguna página: no corría, y sin aviso.
+ */
+function middlewareRoute(file, pagesDir = 'app/pages') {
+    const relative = stripScriptExtension(relativeToPages(file, pagesDir));
+    return '/' + relative.replace(/\.middlewares$/, '').replace(/\/?middlewares$/, '');
+}
+function isMiddlewareFile(file, policy = exports.DEFAULT_EXTENSION_POLICY) {
+    if (isIgnoredModule(file, policy))
+        return false;
+    const ext = scriptExtensionOf(file);
+    if (!ext || !policy.middleware.includes(ext))
+        return false;
+    const name = normalize(file).split('/').pop() ?? '';
+    return name.startsWith('middlewares.') || name.includes('.middlewares.');
+}
+/**
+ * Identificador de una página, sin su extensión ni el prefijo del directorio.
+ *
+ * Es la clave que comparten el catálogo de variantes y el manifest de rutas, así
+ * que dos archivos que sólo difieren en la extensión producen el mismo: es lo
+ * que permite detectar que ambos existen.
+ */
+function pageIdOf(file, pagesDir = 'app/pages') {
+    const relative = relativeToPages(file, pagesDir);
+    return stripScriptExtension(relative);
+}
+/**
+ * Dónde queda un módulo después de compilarse.
+ *
+ * El build emite siempre `.js`, cualquiera sea la extensión de origen, y sanea
+ * los corchetes de los parámetros porque no pueden formar parte de un nombre de
+ * archivo en todos los sistemas.
+ */
+function toCompiledPath(file, policy = exports.DEFAULT_EXTENSION_POLICY, pagesDir = 'app/pages') {
+    // `stripScriptExtension` lanza si no reconoce la extensión, que es lo correcto:
+    // devolver el nombre intacto producía `foo.mjs` → `foo.mjs.js`, un artefacto
+    // que no existe y cuyo fallo aparece recién al importarlo en producción.
+    const relative = stripScriptExtension(relativeToPages(file, pagesDir));
+    return relative.replace(/\[([^\]]+)\]/g, '_$1_') + policy.compiled;
+}
+/**
+ * Dos archivos que producen la misma página son ambiguos.
+ *
+ * Cuál gana dependería del orden en que el sistema de archivos los devolvió, y
+ * ese orden cambia entre sistemas. Mejor fallar al arrancar nombrando los dos.
+ */
+function assertNoModuleCollision(files, pagesDir = 'app/pages', options = {}) {
+    const byId = new Map();
+    for (const file of files) {
+        const id = pageIdOf(file, pagesDir);
+        const previous = byId.get(id);
+        if (previous) {
+            const message = `[ress] "${previous}" y "${file}" definen la misma página. ` +
+                'Cuál gana dependería del orden del sistema de archivos, que cambia entre ' +
+                'sistemas operativos. Dejá uno solo.';
+            // Al construir es un error; en desarrollo se avisa y se sigue con el
+            // primero, para no dejar el servidor caído mientras alguien renombra.
+            if (options.strict)
+                throw new Error(message);
+            console.warn(`${message}\nPor ahora responde "${previous}".`);
+            continue;
+        }
+        byId.set(id, file);
+    }
+}
+/** Los separadores de Windows se normalizan: el resto del framework usa `/`. */
+function normalize(file) {
+    return file.replace(/\\/g, '/');
+}
+function relativeToPages(file, pagesDir) {
+    const normalized = normalize(file);
+    const marker = normalize(pagesDir).replace(/\/$/, '') + '/';
+    const index = normalized.indexOf(marker);
+    return index === -1 ? normalized.replace(/^\//, '') : normalized.slice(index + marker.length);
+}
+/**
+ * Política vigente del proceso.
+ *
+ * El descubrimiento corre en varios lugares que no reciben opciones —el
+ * catálogo, el escaneo de rutas, la carga de middlewares—, así que el plugin la
+ * fija una vez al resolver la configuración y todos leen la misma.
+ */
+let current = exports.DEFAULT_EXTENSION_POLICY;
+function setExtensionPolicy(policy) {
+    current = policy;
+}
+function getExtensionPolicy() {
+    return current;
+}

package/dist/head/resolve.d.ts

@@ -0,0 +1,5 @@
+import type { PlatformInfo } from '../platform';
+import type { CollectedHeadTag, PageConfig, ResolvedPageHead, RobotsConfig } from './types';
+export declare function resolvePageHead(pageConfig: PageConfig | undefined, collected?: readonly CollectedHeadTag[], platform?: PlatformInfo | null): ResolvedPageHead;
+export declare function robotsContent(value: RobotsConfig | undefined): string | undefined;
+export declare function deduplicateHeadTags(tags: readonly CollectedHeadTag[]): CollectedHeadTag[];

package/dist/head/resolve.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePageHead = resolvePageHead;
+exports.robotsContent = robotsContent;
+exports.deduplicateHeadTags = deduplicateHeadTags;
+const platform_tokens_1 = require("../variants/platform-tokens");
+const resolve_1 = require("../variants/resolve");
+const suffix_1 = require("../variants/suffix");
+function resolvePageHead(pageConfig, collected = [], platform) {
+    const config = resolvePageConfigVariant(pageConfig, platform);
+    const tags = deduplicateHeadTags([...configToTags(config), ...collected]);
+    const robotsTag = [...tags].reverse().find((tag) => tag.type === 'meta' && String(tag.attrs.name ?? '').toLowerCase() === 'robots');
+    const robots = sanitizeRobotsValue(robotsTag?.attrs.content);
+    const normalizedTags = robotsTag && robots
+        ? tags.map((tag) => tag === robotsTag
+            ? { ...tag, attrs: { ...tag.attrs, content: robots } }
+            : tag)
+        : tags;
+    return {
+        tags: orderHeadTags(normalizedTags),
+        htmlAttributes: config.htmlAttributes ?? {},
+        bodyAttributes: config.bodyAttributes ?? {},
+        ...(robots ? { robots } : {}),
+    };
+}
+function robotsContent(value) {
+    if (typeof value === 'string')
+        return sanitizeRobotsValue(value);
+    if (!value)
+        return undefined;
+    const directives = [];
+    if (value.index !== undefined)
+        directives.push(value.index ? 'index' : 'noindex');
+    if (value.follow !== undefined)
+        directives.push(value.follow ? 'follow' : 'nofollow');
+    if (value.noarchive)
+        directives.push('noarchive');
+    if (value.nosnippet)
+        directives.push('nosnippet');
+    if (value.noimageindex)
+        directives.push('noimageindex');
+    if (value.notranslate)
+        directives.push('notranslate');
+    return directives.length ? directives.join(', ') : undefined;
+}
+function sanitizeRobotsValue(value) {
+    if (value == null)
+        return undefined;
+    const normalized = String(value).replace(/[\u0000-\u001f\u007f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    return normalized || undefined;
+}
+function resolvePageConfigVariant(pageConfig, platform) {
+    if (!pageConfig)
+        return {};
+    const { variants, ...base } = pageConfig;
+    if (!platform || !variants || Object.keys(variants).length === 0)
+        return base;
+    const available = [
+        { suffix: '', tags: [] },
+        ...Object.keys(variants).sort().map((suffix) => ({
+            suffix,
+            tags: (0, suffix_1.parseVariantSuffix)(suffix, platform_tokens_1.defaultPlatformRegistry),
+        })),
+    ];
+    const selected = (0, resolve_1.resolveVariant)(platform, available, platform_tokens_1.defaultPlatformRegistry);
+    return selected.suffix ? mergeConfig(base, variants[selected.suffix] ?? {}) : base;
+}
+function mergeConfig(base, variant) {
+    return {
+        ...base,
+        ...variant,
+        htmlAttributes: { ...base.htmlAttributes, ...variant.htmlAttributes },
+        bodyAttributes: { ...base.bodyAttributes, ...variant.bodyAttributes },
+        head: {
+            ...base.head,
+            ...variant.head,
+            meta: [...(base.head?.meta ?? []), ...(variant.head?.meta ?? [])],
+            link: [...(base.head?.link ?? []), ...(variant.head?.link ?? [])],
+            script: [...(base.head?.script ?? []), ...(variant.head?.script ?? [])],
+            style: [...(base.head?.style ?? []), ...(variant.head?.style ?? [])],
+            noscript: [...(base.head?.noscript ?? []), ...(variant.head?.noscript ?? [])],
+        },
+    };
+}
+function configToTags(config) {
+    const head = config.head;
+    if (!head)
+        return [];
+    const tags = [];
+    const robots = robotsContent(head.robots);
+    if (head.title !== undefined)
+        tags.push({ type: 'title', attrs: {}, content: head.title });
+    if (robots)
+        tags.push({ type: 'meta', attrs: { name: 'robots', content: robots } });
+    for (const attrs of head.meta ?? [])
+        tags.push({ type: 'meta', attrs });
+    for (const attrs of head.link ?? [])
+        tags.push({ type: 'link', attrs });
+    for (const { content, ...attrs } of head.script ?? [])
+        tags.push({ type: 'script', attrs, content });
+    for (const { content, ...attrs } of head.style ?? [])
+        tags.push({ type: 'style', attrs, content });
+    if (head.base)
+        tags.push({ type: 'base', attrs: head.base });
+    for (const item of head.noscript ?? [])
+        tags.push({ type: 'noscript', attrs: {}, content: item.content });
+    return tags;
+}
+function deduplicateHeadTags(tags) {
+    const output = [];
+    const positions = new Map();
+    for (const tag of tags) {
+        const key = dedupKey(tag);
+        if (!key) {
+            output.push(tag);
+            continue;
+        }
+        const previous = positions.get(key);
+        if (previous === undefined) {
+            positions.set(key, output.length);
+            output.push(tag);
+        }
+        else {
+            output[previous] = tag;
+        }
+    }
+    return output;
+}
+function dedupKey(tag) {
+    if (tag.type === 'title' || tag.type === 'base')
+        return tag.type;
+    if (tag.type === 'meta') {
+        if (tag.attrs.name != null)
+            return `meta:name:${String(tag.attrs.name).toLowerCase()}`;
+        if (tag.attrs.property != null)
+            return `meta:property:${String(tag.attrs.property).toLowerCase()}`;
+        if (tag.attrs.charset != null || tag.attrs.charSet != null)
+            return 'meta:charset';
+    }
+    if (tag.type === 'script' && tag.attrs.src != null)
+        return `script:${String(tag.attrs.src)}`;
+    if (tag.type === 'link' && String(tag.attrs.rel).toLowerCase() === 'canonical')
+        return 'link:canonical';
+    return undefined;
+}
+function orderHeadTags(tags) {
+    return tags
+        .map((tag, index) => ({ tag, index, rank: tagRank(tag) }))
+        .sort((a, b) => a.rank - b.rank || a.index - b.index)
+        .map(({ tag }) => tag);
+}
+function tagRank(tag) {
+    if (tag.type === 'meta' && (tag.attrs.charset != null || tag.attrs.charSet != null))
+        return 0;
+    if (tag.type === 'meta' && String(tag.attrs.name).toLowerCase() === 'viewport')
+        return 1;
+    if (tag.type === 'link' && ['preload', 'modulepreload'].includes(String(tag.attrs.rel).toLowerCase()))
+        return 2;
+    if (tag.type === 'link' && String(tag.attrs.rel).toLowerCase() === 'stylesheet')
+        return 3;
+    if (tag.type === 'title')
+        return 4;
+    if (tag.type === 'meta')
+        return 5;
+    return 6;
+}