blume 0.6.7 → 0.8.0

package/src/astro/index.ts

@@ -1,4 +1,8 @@
-export { generateRuntime, prerenderDepsPlugin } from "./generate.ts";
+export {
+  generateRuntime,
+  prerenderDepsPlugin,
+  serverAppResolvePlugin,
+} from "./generate.ts";
 export type { GenerateResult } from "./generate.ts";
 export { blumeIntegration } from "./integration.ts";
 export type { BlumeIntegrationOptions, BlumePageRoute } from "./integration.ts";

package/src/astro/integration.ts

@@ -30,17 +30,21 @@ const overlayChannel = (): OverlayChannel | undefined =>
  * overlay clears itself on the next successful HMR update.
  */
 export const showBlumeErrorOverlay = (diagnostics: Diagnostic[]): void => {
-  const errors = diagnostics
-    .filter((diagnostic) => diagnostic.severity === "error")
-    .map(enrichDiagnostic);
+  const errors: Diagnostic[] = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.severity === "error") {
+      errors.push(enrichDiagnostic(diagnostic));
+    }
+  }
   const channel = overlayChannel();
   if (errors.length === 0 || !channel) {
     return;
   }
   const body = errors
     .map((diagnostic) => {
+      const lineSuffix = diagnostic.line ? `:${diagnostic.line}` : "";
       const where = diagnostic.file
-        ? `\n  at ${diagnostic.file}${diagnostic.line ? `:${diagnostic.line}` : ""}`
+        ? `\n  at ${diagnostic.file}${lineSuffix}`
         : "";
       const fix = diagnostic.suggestion
         ? `\n  fix: ${diagnostic.suggestion}`
@@ -104,7 +108,7 @@ const negotiateMarkdown =
  * Blume's Astro integration. Mounts user-authored pages from `pages/` into the
  * generated runtime via `injectRoute`, keeping each file in its original
  * location so relative imports and `getStaticPaths` keep working, and teaches
- * the dev server to honour `Accept: text/markdown`.
+ * the dev server to honor `Accept: text/markdown`.
  */
 export const blumeIntegration = (
   options: BlumeIntegrationOptions

package/src/astro/islands.ts

@@ -97,12 +97,14 @@ export const discoverIslands = async (
   const warnings: string[] = [];
   const seen = new Map<string, string>();
 
-  for (const [index, file] of files.entries()) {
+  // Extracted so the skip paths become early `return`s (one `continue` budget
+  // per loop under the lint rule) instead of `continue` statements.
+  const collectIsland = (file: string, source: string): void => {
     const base = basename(file);
     const ext = base.match(ISLAND_FILE)?.groups?.ext;
     const framework = ext ? FRAMEWORK_BY_EXT[ext] : undefined;
     if (!framework) {
-      continue;
+      return;
     }
     const name = base.replace(ISLAND_FILE, "");
     // The name is used verbatim as both an MDX tag and an unquoted object key
@@ -113,22 +115,26 @@ export const discoverIslands = async (
       warnings.push(
         `Island "${file}" must have a PascalCase identifier filename to be used in MDX (letters, digits, and underscores only, e.g. Counter.tsx → <Counter />); skipping it.`
       );
-      continue;
+      return;
     }
     const existing = seen.get(name);
     if (existing) {
       warnings.push(
         `Two islands both resolve to <${name}> ("${existing}" and "${file}"); ignoring the second. Give them distinct filenames.`
       );
-      continue;
+      return;
     }
     seen.set(name, file);
     islands.push({
-      client: readClientMode(sources[index] ?? "", file, warnings),
+      client: readClientMode(source, file, warnings),
       file,
       framework,
       name,
     });
+  };
+
+  for (const [index, file] of files.entries()) {
+    collectIsland(file, sources[index] ?? "");
   }
 
   return { islands, warnings };

package/src/astro/markdown-negotiation.ts

@@ -1,7 +1,7 @@
 /**
  * HTTP content negotiation for the raw-Markdown variants. The `<route>.md`
  * endpoints already serve a page's source verbatim; these helpers let the dev
- * server honour `Accept: text/markdown` by transparently rewriting a page
+ * server honor `Accept: text/markdown` by transparently rewriting a page
  * request to its `.md` variant.
  */
 
@@ -18,7 +18,7 @@ const parseAccept = (accept: string): AcceptEntry[] =>
       .slice(1)
       .map((segment) => segment.trim())
       .find((segment) => segment.startsWith("q="));
-    const q = qSegment ? Number.parseFloat(qSegment.slice(2)) : 1;
+    const q = qSegment ? Number(qSegment.slice(2)) : 1;
     return { q: Number.isNaN(q) ? 1 : q, type };
   });
 

package/src/astro/pages.ts

@@ -1,23 +1,14 @@
 import { extname, relative } from "pathe";
-import { glob } from "tinyglobby";
+import { glob, globSync } from "tinyglobby";
 
+import type { BlumeProject } from "../core/project-graph.ts";
 import type { BlumePageRoute } from "./integration.ts";
 
-/**
- * Discover user `.astro` pages and map them to route patterns. Files keep their
- * original location; only the route pattern is derived (index -> parent,
- * dynamic `[param]` segments preserved).
- */
-export const discoverPages = async (
-  pagesRoot: string
-): Promise<BlumePageRoute[]> => {
-  const files = await glob(["**/*.astro"], {
-    absolute: true,
-    cwd: pagesRoot,
-    onlyFiles: true,
-  });
-  files.sort();
+const PAGE_GLOB = ["**/*.astro"];
 
+/** Map discovered page files to routes; shared by the async/sync discoverers. */
+const toPageRoutes = (pagesRoot: string, files: string[]): BlumePageRoute[] => {
+  files.sort();
   return files.map((file) => {
     const rel = relative(pagesRoot, file);
     const withoutExt = rel.slice(0, rel.length - extname(rel).length);
@@ -32,6 +23,26 @@ export const discoverPages = async (
   });
 };
 
+/**
+ * Discover user `.astro` pages and map them to route patterns. Files keep their
+ * original location; only the route pattern is derived (index -> parent,
+ * dynamic `[param]` segments preserved).
+ */
+export const discoverPages = async (
+  pagesRoot: string
+): Promise<BlumePageRoute[]> =>
+  toPageRoutes(
+    pagesRoot,
+    await glob(PAGE_GLOB, { absolute: true, cwd: pagesRoot, onlyFiles: true })
+  );
+
+/** {@link discoverPages} for synchronous callers (e.g. the sitemap builder). */
+export const discoverPagesSync = (pagesRoot: string): BlumePageRoute[] =>
+  toPageRoutes(
+    pagesRoot,
+    globSync(PAGE_GLOB, { absolute: true, cwd: pagesRoot, onlyFiles: true })
+  );
+
 /**
  * Whether the project already owns `route` — through a custom `.astro` page
  * (injected, so matched on `pattern`) or a content page (matched on `route`).
@@ -57,6 +68,59 @@ export interface OgCustomRoute {
 /** Skip private (`_partial`, `.well-known`) and Astro dynamic (`[param]`) parts. */
 const PRIVATE_SEGMENT = /^[._]/u;
 
+/** Segments of a static, shareable page pattern; null for dynamic/private ones. */
+const staticSegments = (pattern: string): string[] | null => {
+  const segments = pattern.split("/").filter(Boolean);
+  return segments.some(
+    (part) => PRIVATE_SEGMENT.test(part) || part.includes("[")
+  )
+    ? null
+    : segments;
+};
+
+/**
+ * The static routes served by custom `.astro` pages — the same filtering as
+ * {@link customOgRoutes}, but yielding the routes themselves. Feeds the route
+ * sets that must know every servable page beyond the content graph (the link
+ * checker, the sitemap); dynamic (`[param]`) and private segments are skipped
+ * because their concrete URLs can't be enumerated statically.
+ */
+export const customStaticRoutes = (pages: { pattern: string }[]): string[] => {
+  const routes = new Set<string>();
+  for (const { pattern } of pages) {
+    const segments = staticSegments(pattern);
+    if (segments !== null) {
+      routes.add(segments.length === 0 ? "/" : `/${segments.join("/")}`);
+    }
+  }
+  return [...routes];
+};
+
+/**
+ * Whether the generated `/changelog` index route exists for this project —
+ * `generate.ts` (which writes the page) and the sitemap/link validator all
+ * share this check: there are visible `type: changelog` entries — or a
+ * release-backed changelog source, whose route must resolve even when a fetch
+ * fails — and no user content or custom page already owns `/changelog`.
+ */
+export const hasGeneratedChangelog = (
+  project: BlumeProject,
+  userPages: { pattern: string }[]
+): boolean => {
+  const hasChangelog = project.graph.pages.some(
+    (page) =>
+      page.contentType === "changelog" &&
+      !(page.meta.draft || page.meta.sidebar.hidden)
+  );
+  const hasChangelogSource = (project.config.content.sources ?? []).some(
+    (source) => source.type === "github-releases"
+  );
+  return (
+    (hasChangelog || hasChangelogSource) &&
+    !routeIsTaken(userPages, project.graph.pages, "/changelog")
+  );
+};
+
 const humanizeSegment = (segment: string): string =>
   segment
     .split(/[-_]/u)
@@ -80,20 +144,23 @@ export const customOgRoutes = (
 ): OgCustomRoute[] => {
   const seen = new Set<string>();
   const routes: OgCustomRoute[] = [];
-  for (const { pattern } of pages) {
-    const segments = pattern.split("/").filter(Boolean);
-    if (
-      segments.some((part) => PRIVATE_SEGMENT.test(part) || part.includes("["))
-    ) {
-      continue;
+  // Extracted so the skip paths become early `return`s (one `continue` budget
+  // per loop under the lint rule) instead of `continue` statements.
+  const collectRoute = (pattern: string): void => {
+    const segments = staticSegments(pattern);
+    if (segments === null) {
+      return;
     }
     const slug = segments.length === 0 ? "index" : segments.join("/");
     if (seen.has(slug)) {
-      continue;
+      return;
     }
     seen.add(slug);
     const last = segments.at(-1);
     routes.push({ slug, title: last ? humanizeSegment(last) : siteTitle });
+  };
+  for (const { pattern } of pages) {
+    collectRoute(pattern);
   }
   return routes;
 };