@iterant/site-runtime 3.11.0 → 3.11.2

package/docs/runtime-contract.md

@@ -50,7 +50,7 @@ runtime and says so.
 
 <!-- generated: available libraries -->
 
-_Generated from package.json by scripts/generate-kit-table.mjs. Runtime 3.11.0._
+_Generated from package.json by scripts/generate-kit-table.mjs. Runtime 3.11.2._
 
 **Toolchain** (this package owns the version; do NOT declare these):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iterant/site-runtime",
-  "version": "3.11.0",
+  "version": "3.11.2",
   "type": "module",
   "description": "The platform layer every Iterant brand site runs on: content grammar, collection schemas, SEO head and JSON-LD, layout core, Astro config preset, dev integrations and the verify gates.",
   "scripts": {

package/src/lib/sitemap/get-sitemap-paths.ts

@@ -33,11 +33,15 @@ function resolvePagesDir({ pagesDir, root }: SitemapPathsOptions): string {
 
 /**
  * Every advertised page entry's route (neither draft nor noindex), home
- * excluded (@astrojs/sitemap already emits the site root). Returns `{ paths, pagesDir }` so a caller can report
+ * excluded (@astrojs/sitemap already emits the site root), beside `deny`: the
+ * routes of the entries that are NOT advertised. The integration crawls the
+ * prerendered pages itself and would list those a second way, so the caller
+ * drops them through its filter. Returns `pagesDir` so a caller can report
  * WHERE it looked when the answer is empty.
  */
 export function getSitemapPaths(options: SitemapPathsOptions = {}): {
   paths: string[];
+  deny: string[];
   entryCount: number;
   pagesDir: string;
 } {
@@ -46,22 +50,24 @@ export function getSitemapPaths(options: SitemapPathsOptions = {}): {
   try {
     entries = readdirSync(pagesDir, { recursive: true }) as string[];
   } catch {
-    return { paths: [], pagesDir, entryCount: 0 }; // no page entries yet
+    return { paths: [], deny: [], pagesDir, entryCount: 0 }; // no page entries yet
   }
   const jsonEntries = entries.filter((entry) => entry.endsWith(".json"));
   const entryCount = jsonEntries.length;
-  const paths = jsonEntries
-    .filter((rel) => /\.json$/i.test(rel))
-    .map((rel) => {
-      try {
-        const data = JSON.parse(readFileSync(join(pagesDir, rel), "utf8"));
-        if (typeof data.route !== "string") return null;
-        if (!isAdvertised(data, { includeDrafts: false })) return null;
-        return data.route as string;
-      } catch {
-        return null; // malformed entry; the build will surface the schema error
+  const paths: string[] = [];
+  const deny: string[] = [];
+  for (const rel of jsonEntries) {
+    try {
+      const data = JSON.parse(readFileSync(join(pagesDir, rel), "utf8"));
+      if (typeof data.route !== "string") continue;
+      if (!isAdvertised(data, { includeDrafts: false })) {
+        deny.push(data.route as string);
+      } else if (data.route !== "/") {
+        paths.push(data.route as string);
       }
-    })
-    .filter((path): path is string => path !== null && path !== "/");
-  return { paths, pagesDir, entryCount };
+    } catch {
+      // malformed entry; the build will surface the schema error
+    }
+  }
+  return { paths, deny, pagesDir, entryCount };
 }

package/src/lib/sitemap/sitemap-with-custom-pages-plugin.ts

@@ -14,16 +14,41 @@ const PLACEHOLDER = "https://starter.invalid";
 // names them here.
 const PLATFORM_DENY = new Set(["/under-construction"]);
 
-/** Whether a sitemap URL may be listed: everything but the platform's own routes. */
-export function sitemapPageAllowed(url: string): boolean {
+/** Whether a sitemap URL may be listed: neither a platform route nor a denied
+ *  entry route (a draft or a noindex page), whichever way the integration
+ *  found it. */
+export function sitemapPageAllowed(
+  url: string,
+  deny: ReadonlySet<string> = new Set(),
+): boolean {
   try {
     const pathname = new URL(url).pathname.replace(/\/+$/, "") || "/";
-    return !PLATFORM_DENY.has(pathname);
+    return !PLATFORM_DENY.has(pathname) && !deny.has(pathname);
   } catch {
     return true;
   }
 }
 
+/** The serialize step's URL work, extracted so it can be tested: resolve the
+ *  placeholder origin against the real site, then drop a URL this build has
+ *  already emitted. The integration de-duplicates by exact string before
+ *  serialize runs, so a route that is both a page entry and a prerendered
+ *  shell arrives twice, under the crawl's real origin and under ours, and
+ *  becomes one URL only here. Returning nothing drops the item. */
+export function resolveSitemapUrl(
+  url: string,
+  site: string,
+  emitted: Set<string>,
+): string | undefined {
+  const resolved =
+    site && url.startsWith(PLACEHOLDER)
+      ? site + url.slice(PLACEHOLDER.length)
+      : url;
+  if (emitted.has(resolved)) return undefined;
+  emitted.add(resolved);
+  return resolved;
+}
+
 export type SitemapWithCustomPagesOptions = SitemapOptions &
   SitemapPathsOptions;
 
@@ -31,6 +56,8 @@ export function sitemapWithCustomPages(
   options: SitemapWithCustomPagesOptions = {},
 ): AstroIntegration[] {
   let resolvedSite = "";
+  // Emptied per build in astro:config:done.
+  const emitted = new Set<string>();
   const { pagesDir, root, ...sitemapOptions } = options;
   const userSerialize = sitemapOptions.serialize;
   const userFilter = sitemapOptions.filter;
@@ -41,6 +68,9 @@ export function sitemapWithCustomPages(
   // This integration is ordered ahead of @astrojs/sitemap, so the array is
   // populated before anything reads it.
   const customPages: string[] = [...(sitemapOptions.customPages ?? [])];
+  // Filled beside customPages: the entry routes the integration must not list
+  // from its own crawl of prerendered pages.
+  const denied = new Set<string>();
 
   return [
     {
@@ -49,6 +79,7 @@ export function sitemapWithCustomPages(
         "astro:config:setup": ({ config, logger }) => {
           const {
             paths,
+            deny,
             pagesDir: searched,
             entryCount,
           } = getSitemapPaths({
@@ -68,6 +99,9 @@ export function sitemapWithCustomPages(
               `page entries in ${searched} are all drafts or the site root; the sitemap lists no SSR routes yet`,
             );
           }
+          for (const path of deny) {
+            denied.add(path.replace(/\/+$/, "") || "/");
+          }
           for (const path of paths) {
             customPages.push(
               `${PLACEHOLDER}${path.startsWith("/") ? path : `/${path}`}`,
@@ -75,6 +109,7 @@ export function sitemapWithCustomPages(
           }
         },
         "astro:config:done": ({ config }) => {
+          emitted.clear();
           if (config.site) {
             resolvedSite = String(config.site).replace(/\/$/, "");
           }
@@ -85,11 +120,12 @@ export function sitemapWithCustomPages(
       ...sitemapOptions,
       customPages,
       filter: (page) =>
-        sitemapPageAllowed(page) && (userFilter ? userFilter(page) : true),
+        sitemapPageAllowed(page, denied) &&
+        (userFilter ? userFilter(page) : true),
       serialize(item) {
-        if (resolvedSite && item.url.startsWith(PLACEHOLDER)) {
-          item.url = resolvedSite + item.url.slice(PLACEHOLDER.length);
-        }
+        const url = resolveSitemapUrl(item.url, resolvedSite, emitted);
+        if (!url) return undefined;
+        item.url = url;
         return userSerialize ? userSerialize(item) : item;
       },
     }),