@elia97/officina 0.9.1 → 0.11.0

package/dist/lib/routes.js

@@ -28,7 +28,7 @@ export function routeOf(htmlPath, dist) {
     return route.replace(/\.html$/, '') || '/';
 }
 const SSR_OPT_OUT = /^\s*export\s+const\s+prerender\s*=\s*false\b/m;
-function pageRouteOf(file, pagesDir) {
+export function pageRouteOf(file, pagesDir) {
     return (toPosix(file, pagesDir)
         .replace(/\.astro$/, '')
         .replace(/\/index$/, '') || '/');
@@ -41,14 +41,14 @@ function segmentPattern(segment) {
 const TRAILING_REST_SEGMENT = /\/\[\.\.\.[^/]*\]$/;
 // Anche un segmento rest finale fa match col vuoto: `paginate()` emette la prima pagina come
 // percorso nudo (`/news`, mai `/news/1`), quindi esigere un segmento boccia un archivio di una pagina.
-function routePattern(route) {
+export function routePattern(route) {
     const body = (path) => path.split('/').map(segmentPattern).join('/');
     if (!TRAILING_REST_SEGMENT.test(route))
         return new RegExp(`^${body(route)}$`);
     return new RegExp(`^${body(route.replace(TRAILING_REST_SEGMENT, ''))}(?:/.*)?$`);
 }
-export function expectedRoutes(pages, pagesDir) {
-    const expectations = { exact: [], patterns: [], ssr: [] };
+export function expectedRoutes(pages, pagesDir, disabled = []) {
+    const expectations = { exact: [], patterns: [], disabled: [], ssr: [] };
     for (const { file, source } of pages) {
         if (SSR_OPT_OUT.test(source)) {
             expectations.ssr.push(file);
@@ -59,28 +59,52 @@ export function expectedRoutes(pages, pagesDir) {
             expectations.exact.push({ route, file });
             continue;
         }
-        expectations.patterns.push({ pattern: routePattern(route), label: route, file });
+        const target = disabled.includes(route) ? expectations.disabled : expectations.patterns;
+        target.push({ pattern: routePattern(route), label: route, file });
     }
     return expectations;
 }
+// Il manifest di Astro nomina una rotta resa a richiesta col suo pattern (`/blog/[slug]`), non coi percorsi che serve.
+const emits = ({ pattern, label }, { html, ssr }) => html.some((route) => pattern.test(route)) || ssr.includes(label);
 /** [HARD] Guardia fail-open: ogni asserzione per rotta itera sulle pagine emesse, quindi una dist vuota non asserisce niente. */
 export function missingRouteFailures(expected, emitted, dist) {
-    if (emitted.length === 0) {
+    if (emitted.html.length + emitted.ssr.length === 0) {
         return [`${dist} non contiene nessun .html: nessuna rotta misurata, quindi i budget per rotta non affermano niente`];
     }
     const failures = [];
-    const routes = new Set(emitted);
+    const routes = new Set([...emitted.html, ...emitted.ssr]);
     for (const { route, file } of expected.exact) {
         if (!routes.has(route))
             failures.push(`rotta mancante ${route}: ${file} è prerenderizzata ma non ha emesso HTML`);
     }
-    for (const { pattern, label, file } of expected.patterns) {
-        if (emitted.some((route) => pattern.test(route)))
+    for (const page of expected.patterns) {
+        if (emits(page, emitted))
             continue;
-        failures.push(`rotta mancante ${label}: ${file} è prerenderizzata ma getStaticPaths non ha emesso niente`);
+        failures.push(`rotta mancante ${page.label}: ${page.file} è prerenderizzata ma getStaticPaths non ha emesso niente`);
     }
     return failures;
 }
+const SHOWN = 3;
+export const listed = (routes) => routes.length <= SHOWN ? routes.join(', ') : `${routes.slice(0, SHOWN).join(', ')} e altre ${routes.length - SHOWN}`;
+export function disabledRouteFailures(expected, { html, ssr }) {
+    const exact = new Set(expected.exact.map(({ route }) => route));
+    const unexplained = html.filter((route) => !exact.has(route) && !expected.patterns.some(({ pattern }) => pattern.test(route)));
+    return expected.disabled.flatMap(({ pattern, label }) => {
+        if (ssr.includes(label)) {
+            return [
+                `rotta spenta ${label}: è in \`routes.disabled\`, ma la build la rende a richiesta, e si spegne solo una pagina prerenderizzata`,
+            ];
+        }
+        const routes = unexplained.filter((route) => pattern.test(route)).sort();
+        if (routes.length === 0)
+            return [];
+        return [`rotta spenta ${label}: è in \`routes.disabled\`, ma la build ha emesso ${listed(routes)}`];
+    });
+}
+export function unknownDisabled(expected, disabled = []) {
+    const known = new Set(expected.disabled.map(({ label }) => label));
+    return disabled.filter((label) => !known.has(label));
+}
 /** I pattern dinamici che `officina.config.ts` non ha ancora mandato nessuno a visitare. */
 export function missingRepresentatives(expected, representatives = {}) {
     return expected.patterns

package/dist/lib/validate.js

@@ -25,8 +25,6 @@ export const aRecordOf = (item) => (value, path) => isRecord(value)
     ? Object.entries(value).flatMap(([key, entry]) => item(entry, `${path}.${key}`))
     : [problem(path, 'un oggetto', value)];
 export const oneOf = (expected, allowed) => (value, path) => allowed.includes(value) ? [] : [problem(path, expected, value)];
-// Una voce non dichiarata è un errore: `sitUrl` al posto di `siteUrl` non deve passare in
-// silenzio, che è il modo esatto in cui una configurazione smette di dire qualcosa.
 export const aShape = (fields) => (value, path) => {
     if (!isRecord(value))
         return [problem(path, 'un oggetto', value)];

package/dist/lib/vercel-build.d.ts

@@ -5,7 +5,9 @@ export type ServerFile = {
 export type SsrRoute = {
     route: string;
     entries: string[];
+    stylesheets: string[] | null;
     unmapped: boolean;
     unknownIslands: string[];
 };
 export declare function ssrRoutes(files: readonly ServerFile[]): SsrRoute[] | null;
+export declare function onDemandPatterns(files: readonly ServerFile[]): RegExp[] | null;

package/dist/lib/vercel-build.js

@@ -1,6 +1,8 @@
 import { posix } from 'node:path';
+import { routePattern } from './routes.js';
 const MANIFEST_CALL = 'deserializeManifest({';
-const ASSET = /^_astro\/([^/]+\.js)$/;
+const ASSET = /^(?:.*\/)?_astro\/([^/?#]+\.js)(?:[?#].*)?$/;
+const STYLESHEET = /^(?:.*\/)?_astro\/([^?#]+\.css)(?:[?#].*)?$/;
 const RENDERER_RUNTIME = /^@astrojs\/[\w-]+\/client\.js$/;
 const COMPONENT_SCRIPT = '?astro&type=script';
 const PAGE_ROUTE = /\["(src\/pages\/[^"]+)", (_page\d+)\]/g;
@@ -65,7 +67,7 @@ function serverClosure(start, files, manifestFile) {
     }
     return [...reached.values()];
 }
-const assetOf = (value) => value?.match(ASSET)?.[1];
+const assetOf = (value, pattern = ASSET) => value?.match(pattern)?.[1];
 function clientModules(manifest) {
     const inlined = new Set((manifest.inlinedScripts ?? []).map(([specifier]) => specifier));
     const modules = new Map();
@@ -87,20 +89,50 @@ function routeEntries(page, texts, modules) {
 const unknownIslands = (texts, modules) => [...new Set(texts.flatMap((text) => [...text.matchAll(ISLAND_PATH)].map(([, path]) => path)))]
     .filter((path) => !modules.has(path))
     .sort();
-function ssrPage({ scripts = [], routeData }) {
+const routeStylesheets = (styles) => !Array.isArray(styles)
+    ? null
+    : [
+        ...new Set(styles
+            .filter((style) => style.type === 'external')
+            .map((style) => assetOf(style.src, STYLESHEET))
+            .filter((name) => name !== undefined)),
+    ].sort();
+function ssrPage({ scripts = [], styles, routeData }) {
     if (routeData?.type !== 'page' || routeData.origin !== 'project' || routeData.prerender !== false)
         return [];
     const { route, component } = routeData;
-    return typeof route === 'string' && typeof component === 'string' ? [{ scripts, route, component }] : [];
+    return typeof route === 'string' && typeof component === 'string' ? [{ scripts, styles, route, component }] : [];
 }
-export function ssrRoutes(files) {
-    for (const file of files) {
-        const manifest = parseManifest(file.source);
+function firstManifest(files) {
+    for (const host of files) {
+        const manifest = parseManifest(host.source);
         if (manifest !== null)
-            return routesOf(file, manifest, files);
+            return { host, manifest };
     }
     return null;
 }
+export function ssrRoutes(files) {
+    const found = firstManifest(files);
+    return found === null ? null : routesOf(found.host, found.manifest, files);
+}
+// `routePattern` non legge i segmenti misti (`[slug].md`, `post-[id]`), che il pattern del manifest di Astro sì.
+function astroPattern(route, pattern) {
+    if (typeof pattern === 'string') {
+        try {
+            return new RegExp(pattern);
+        }
+        catch { }
+    }
+    return routePattern(route);
+}
+export function onDemandPatterns(files) {
+    const found = firstManifest(files);
+    if (found === null)
+        return null;
+    return (found.manifest.routes ?? []).flatMap(({ routeData }) => routeData?.prerender === false && typeof routeData.route === 'string'
+        ? [astroPattern(routeData.route, routeData.pattern)]
+        : []);
+}
 function routesOf(host, manifest, files) {
     const sources = new Map(files.map((file) => [file.path, file.source]));
     const chunks = pageChunks(host);
@@ -111,6 +143,7 @@ function routesOf(host, manifest, files) {
         return {
             route: page.route,
             entries: routeEntries(page, texts, modules),
+            stylesheets: routeStylesheets(page.styles),
             unmapped: chunk === undefined,
             unknownIslands: unknownIslands(texts, modules),
         };

package/dist/smoke.js

@@ -1,4 +1,2 @@
-// I pezzi con cui un progetto compone i propri controlli di smoke: `smoke.checks` sostituisce la
-// lista del pacchetto, quindi chi ne toglie uno ricompone la lista da qui.
 export { NON_HTML_ROUTES } from './lib/routes.js';
 export { checkBotIdChallenge, checkCanonicalHost, checkPages, checkSecurityHeaders, checkTrailingSlash, DEFAULT_CHECKS, SECURITY_HEADERS, } from './lib/smoke-production.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elia97/officina",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "Gli strumenti dei progetti nati dai template di Elia: gate di qualità, generatori e verifiche di build e di produzione.",
   "type": "module",
   "license": "MIT",
@@ -48,9 +48,10 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run --coverage",
     "format": "biome check --write .",
+    "check:comments": "node src/bin.ts check comments --strict",
     "check:deadcode": "fallow dead-code",
     "check:health": "fallow health --complexity --coverage coverage/coverage-final.json",
-    "ci": "biome ci --error-on-warnings . && pnpm run typecheck && pnpm run check:deadcode && pnpm run test && pnpm run check:health",
+    "ci": "biome ci --error-on-warnings . && pnpm run typecheck && pnpm run check:deadcode && pnpm run check:comments && pnpm run test && pnpm run check:health",
     "test:pack": "bash scripts/pack-test.sh"
   },
   "devDependencies": {