blume 0.6.7 → 0.7.0

package/src/core/sources/github-releases.ts

@@ -88,7 +88,8 @@ const releaseToEntry = (release: GithubRelease): SourceEntry => {
     type: "changelog",
   };
   const raw = matter.stringify(`${body}\n`, data);
-  const ref = `${slugifyTag(release.tag_name) || `release-${release.id}`}.md`;
+  const fallbackRef = `release-${release.id}`;
+  const ref = `${slugifyTag(release.tag_name) || fallbackRef}.md`;
   return {
     body: { format: "md", text: body },
     data,

package/src/core/sources/mdx-remote.ts

@@ -37,49 +37,48 @@ const REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/u;
 const escapeChar = (char: string): string =>
   REGEX_SPECIAL.test(char) ? `\\${char}` : char;
 
+/** Translate one glob token at `i` into RegExp source + the next index. */
+const globToken = (
+  pattern: string,
+  i: number
+): { source: string; next: number } => {
+  const char = pattern[i] ?? "";
+  if (char === "*") {
+    if (pattern[i + 1] === "*") {
+      // `**/` spans zero or more whole segments — `docs/**/guide.md` must
+      // match `docs/guide.md` and `docs/a/guide.md` but not `docs/subguide.md`.
+      if (pattern[i + 2] === "/") {
+        return { next: i + 3, source: "(?:.*/)?" };
+      }
+      return { next: i + 2, source: ".*" };
+    }
+    return { next: i + 1, source: "[^/]*" };
+  }
+  if (char === "?") {
+    return { next: i + 1, source: "[^/]" };
+  }
+  if (char === "{") {
+    const end = pattern.indexOf("}", i);
+    if (end !== -1) {
+      const options = pattern
+        .slice(i + 1, end)
+        .split(",")
+        .map((part) => [...part].map(escapeChar).join(""))
+        .join("|");
+      return { next: end + 1, source: `(?:${options})` };
+    }
+  }
+  return { next: i + 1, source: escapeChar(char) };
+};
+
 /** Compile a glob (`**`, `*`, `?`, `{a,b}`) into an anchored RegExp. */
 const globToRegExp = (pattern: string): RegExp => {
   let source = "";
   let i = 0;
   while (i < pattern.length) {
-    const char = pattern[i] ?? "";
-    if (char === "*") {
-      if (pattern[i + 1] === "*") {
-        i += 2;
-        // `**/` spans zero or more whole segments — `docs/**/guide.md` must
-        // match `docs/guide.md` and `docs/a/guide.md` but not `docs/subguide.md`.
-        if (pattern[i] === "/") {
-          i += 1;
-          source += "(?:.*/)?";
-        } else {
-          source += ".*";
-        }
-        continue;
-      }
-      source += "[^/]*";
-      i += 1;
-      continue;
-    }
-    if (char === "?") {
-      source += "[^/]";
-      i += 1;
-      continue;
-    }
-    if (char === "{") {
-      const end = pattern.indexOf("}", i);
-      if (end !== -1) {
-        const options = pattern
-          .slice(i + 1, end)
-          .split(",")
-          .map((part) => [...part].map(escapeChar).join(""))
-          .join("|");
-        source += `(?:${options})`;
-        i = end + 1;
-        continue;
-      }
-    }
-    source += escapeChar(char);
-    i += 1;
+    const token = globToken(pattern, i);
+    source += token.source;
+    i = token.next;
   }
   return new RegExp(`^${source}$`, "u");
 };
@@ -137,15 +136,22 @@ const enumerateGithub = async (
     truncated?: boolean;
   };
   const prefix = base ? `${base}/` : "";
-  const refs = (body.tree ?? [])
-    .filter((node) => node.type === "blob" && node.path.startsWith(prefix))
-    .map((node) => node.path.slice(prefix.length))
-    .filter((rel) => matchesInclude(rel, include))
-    .map((rel) => ({
-      editUrl: `https://github.com/${owner}/${repo}/edit/${ref}/${prefix}${rel}`,
-      fetchUrl: `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${prefix}${rel}`,
-      ref: rel,
-    }));
+  const refs = (body.tree ?? []).flatMap((node) => {
+    if (!(node.type === "blob" && node.path.startsWith(prefix))) {
+      return [];
+    }
+    const rel = node.path.slice(prefix.length);
+    if (!matchesInclude(rel, include)) {
+      return [];
+    }
+    return [
+      {
+        editUrl: `https://github.com/${owner}/${repo}/edit/${ref}/${prefix}${rel}`,
+        fetchUrl: `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${prefix}${rel}`,
+        ref: rel,
+      },
+    ];
+  });
   // GitHub caps the recursive tree response (~100k entries / 7MB) and flags it
   // with `truncated`; ignoring it would silently import only part of the repo.
   return { refs, truncated: body.truncated === true };
@@ -173,13 +179,11 @@ export const mdxRemoteSource = (
     }
     if (options.files && options.url) {
       const base = options.url.replace(/\/$/u, "");
-      const refs = options.files
-        .filter((ref) => matchesInclude(ref, options.include))
-        .map((ref) => ({
-          editUrl: `${base}/${ref}`,
-          fetchUrl: `${base}/${ref}`,
-          ref,
-        }));
+      const refs = options.files.flatMap((ref) =>
+        matchesInclude(ref, options.include)
+          ? [{ editUrl: `${base}/${ref}`, fetchUrl: `${base}/${ref}`, ref }]
+          : []
+      );
       return { refs, truncated: false };
     }
     throw new BlumeError({

package/src/core/sources/normalize.ts

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import GithubSlugger from "github-slugger";
 import { extname } from "pathe";
 
+import { withBasePath } from "../base-path.ts";
 import { diagnosticsFromZod } from "../diagnostics.ts";
 import { localePlacement, localizeRoute } from "../i18n.ts";
 import { pageMetaSchema } from "../schema.ts";
@@ -45,6 +46,29 @@ const titleCase = (value: string): string =>
     .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
     .join(" ");
 
+/** Fold one raw path part into the accumulating route segments/groups. */
+const addRouteSegment = (
+  part: string,
+  segments: string[],
+  groups: string[]
+): void => {
+  // A leading/trailing/double slash yields an empty part; keeping it would
+  // produce a malformed route (`//foo`, `/foo/`) that nothing can link to.
+  if (part === "") {
+    return;
+  }
+  const group = groupLabel(part);
+  if (group !== null) {
+    groups.push(group);
+    return;
+  }
+  const clean = stripNumericPrefix(part);
+  if (clean === "index") {
+    return;
+  }
+  segments.push(clean);
+};
+
 /** Convert a content-root-relative path into URL + nav metadata. */
 const mapRoute = (
   relativePath: string
@@ -59,21 +83,7 @@ const mapRoute = (
   const groups: string[] = [];
 
   for (const part of rawParts) {
-    // A leading/trailing/double slash yields an empty part; keeping it would
-    // produce a malformed route (`//foo`, `/foo/`) that nothing can link to.
-    if (part === "") {
-      continue;
-    }
-    const group = groupLabel(part);
-    if (group !== null) {
-      groups.push(group);
-      continue;
-    }
-    const clean = stripNumericPrefix(part);
-    if (clean === "index") {
-      continue;
-    }
-    segments.push(clean);
+    addRouteSegment(part, segments, groups);
   }
 
   const route = segments.length === 0 ? "/" : `/${segments.join("/")}`;
@@ -95,25 +105,35 @@ const ATX_HEADING = /^(?<hashes>#{1,6})\s+(?<text>.+?)(?:\s+#+)?\s*$/u;
  * (a hand slugify collapses `--`; github-slugger keeps it) and resolves repeated
  * headings the same way (`setup`, `setup-1`).
  */
+/** Scan one line for an ATX heading; returns the next fenced-block state. */
+const scanHeadingLine = (
+  line: string,
+  inFence: boolean,
+  slugger: GithubSlugger,
+  headings: Heading[]
+): boolean => {
+  if (CODE_FENCE.test(line.trimStart())) {
+    return !inFence;
+  }
+  if (inFence) {
+    return inFence;
+  }
+  const match = line.match(ATX_HEADING);
+  if (match?.groups) {
+    const depth = match.groups.hashes?.length ?? 1;
+    const text = (match.groups.text ?? "").trim();
+    headings.push({ depth, slug: slugger.slug(text), text });
+  }
+  return inFence;
+};
+
 export const extractHeadings = (body: string): Heading[] => {
   const headings: Heading[] = [];
   const slugger = new GithubSlugger();
   let inFence = false;
 
   for (const line of body.split("\n")) {
-    if (CODE_FENCE.test(line.trimStart())) {
-      inFence = !inFence;
-      continue;
-    }
-    if (inFence) {
-      continue;
-    }
-    const match = line.match(ATX_HEADING);
-    if (match?.groups) {
-      const depth = match.groups.hashes?.length ?? 1;
-      const text = (match.groups.text ?? "").trim();
-      headings.push({ depth, slug: slugger.slug(text), text });
-    }
+    inFence = scanHeadingLine(line, inFence, slugger, headings);
   }
 
   return headings;
@@ -126,6 +146,43 @@ const INLINE_CODE = /`[^`]*`/gu;
  * Extract link targets from a markdown body for later validation, recording the
  * 1-based line/column of each target. Skips fenced code blocks and inline code.
  */
+/** Scan one line for link targets; returns the next fenced-block state. */
+const scanLinkLine = (
+  line: string,
+  lineNumber: number,
+  inFence: boolean,
+  links: PageLink[]
+): boolean => {
+  if (CODE_FENCE.test(line.trimStart())) {
+    return !inFence;
+  }
+  if (inFence) {
+    return inFence;
+  }
+  // Blank out inline code spans (`[label](/x)` shown as syntax, not a link)
+  // with same-length padding so recorded columns stay accurate.
+  const masked = line.replaceAll(INLINE_CODE, (span) =>
+    " ".repeat(span.length)
+  );
+  for (const match of masked.matchAll(MD_LINK)) {
+    const target = match.groups?.target;
+    if (target === undefined || match.index === undefined) {
+      continue;
+    }
+    // Locate the target from the `](` boundary rather than searching for the
+    // target text from the match start — otherwise a label that contains the
+    // same text (e.g. `[/a/b](/a/b)`) reports the column inside the label. The
+    // label can't contain `]`, so `](` is unambiguous.
+    const targetOffset = match.index + match[0].indexOf("](") + "](".length;
+    links.push({
+      column: targetOffset + 1,
+      line: lineNumber,
+      target,
+    });
+  }
+  return inFence;
+};
+
 export const extractLinks = (body: string): PageLink[] => {
   const links: PageLink[] = [];
   let inFence = false;
@@ -133,34 +190,7 @@ export const extractLinks = (body: string): PageLink[] => {
 
   for (const line of body.split("\n")) {
     lineNumber += 1;
-    if (CODE_FENCE.test(line.trimStart())) {
-      inFence = !inFence;
-      continue;
-    }
-    if (inFence) {
-      continue;
-    }
-    // Blank out inline code spans (`[label](/x)` shown as syntax, not a link)
-    // with same-length padding so recorded columns stay accurate.
-    const masked = line.replaceAll(INLINE_CODE, (span) =>
-      " ".repeat(span.length)
-    );
-    for (const match of masked.matchAll(MD_LINK)) {
-      const target = match.groups?.target;
-      if (target === undefined || match.index === undefined) {
-        continue;
-      }
-      // Locate the target from the `](` boundary rather than searching for the
-      // target text from the match start — otherwise a label that contains the
-      // same text (e.g. `[/a/b](/a/b)`) reports the column inside the label. The
-      // label can't contain `]`, so `](` is unambiguous.
-      const targetOffset = match.index + match[0].indexOf("](") + "](".length;
-      links.push({
-        column: targetOffset + 1,
-        line: lineNumber,
-        target,
-      });
-    }
+    inFence = scanLinkLine(line, lineNumber, inFence, links);
   }
 
   return links;
@@ -179,26 +209,33 @@ const JSX_OPEN = /<(?<tag>[A-Z][A-Za-z0-9]*)/gu;
  * strings so code samples and prose don't count. Powers the missing-component
  * diagnostic.
  */
+/** Scan one line for JSX component tags; returns the next fenced-block state. */
+const scanTagLine = (
+  line: string,
+  inFence: boolean,
+  tags: Set<string>
+): boolean => {
+  if (CODE_FENCE.test(line.trimStart())) {
+    return !inFence;
+  }
+  if (inFence) {
+    return inFence;
+  }
+  const clean = line.replaceAll(INLINE_CODE, "").replaceAll(DOUBLE_QUOTED, "");
+  for (const match of clean.matchAll(JSX_OPEN)) {
+    const tag = match.groups?.tag;
+    if (tag) {
+      tags.add(tag);
+    }
+  }
+  return inFence;
+};
+
 export const extractComponentTags = (body: string): string[] => {
   const tags = new Set<string>();
   let inFence = false;
   for (const line of body.split("\n")) {
-    if (CODE_FENCE.test(line.trimStart())) {
-      inFence = !inFence;
-      continue;
-    }
-    if (inFence) {
-      continue;
-    }
-    const clean = line
-      .replaceAll(INLINE_CODE, "")
-      .replaceAll(DOUBLE_QUOTED, "");
-    for (const match of clean.matchAll(JSX_OPEN)) {
-      const tag = match.groups?.tag;
-      if (tag) {
-        tags.add(tag);
-      }
-    }
+    inFence = scanTagLine(line, inFence, tags);
   }
   return [...tags];
 };
@@ -323,10 +360,16 @@ export const normalizeEntry = (
 
   // One record per locale this entry maps to (one normally; every locale for a
   // shared `$` file). All share the same id, source ref, and translation key.
+  // `basePath` is applied outermost — after locale prefixing — so the route
+  // reads `{basePath}/{locale?}/{prefix?}/…`; `navPath` and `translationKey`
+  // stay base-less so the nav tree and translation matching are unaffected.
   const pages = locales.map((locale) => ({
     ...base,
     locale,
-    route: i18n ? localizeRoute(logicalRoute, locale, i18n) : logicalRoute,
+    route: withBasePath(
+      ctx.basePath ?? "",
+      i18n ? localizeRoute(logicalRoute, locale, i18n) : logicalRoute
+    ),
   }));
 
   return { diagnostics: [], pages };

package/src/core/sources/notion.ts

@@ -153,7 +153,7 @@ const withNotionRetry = async <T>(call: () => Promise<T>): Promise<T> => {
   let lastError: unknown;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
     try {
-      // oxlint-disable-next-line no-await-in-loop -- sequential retry attempts
+      // oxlint-disable-next-line no-await-in-loop, react-doctor/async-await-in-loop -- sequential retry attempts, not independent
       return await call();
     } catch (error) {
       lastError = error;
@@ -372,9 +372,10 @@ export const notionSource = (
     );
     // Join with a blank line, except between consecutive list items, which stay
     // tight so they render as a single list rather than separate loose ones.
-    const pairs = blocks
-      .map((block, i) => ({ block, text: parts[i] ?? "" }))
-      .filter((pair) => pair.text);
+    const pairs = blocks.flatMap((block, i) => {
+      const text = parts[i] ?? "";
+      return text ? [{ block, text }] : [];
+    });
     return pairs
       .map((pair, i) => {
         if (i === 0) {
@@ -460,6 +461,19 @@ export const notionSource = (
     };
   };
 
+  // Hoisted out of `load` so the retry closure doesn't nest past the linter's
+  // 4-level limit (source factory → queryDatabase → withNotionRetry callback).
+  const queryDatabase = (
+    client: NotionClientLike,
+    cursor?: string
+  ): Promise<NotionList<NotionPage>> =>
+    withNotionRetry(() =>
+      client.databases.query({
+        database_id: options.database,
+        start_cursor: cursor,
+      })
+    );
+
   const load = async (
     refresh = ctx?.refresh ?? true
   ): Promise<SourceLoadResult> => {
@@ -470,12 +484,7 @@ export const notionSource = (
       async () => {
         const client = await resolveClient();
         const pages = await collectAll((cursor) =>
-          withNotionRetry(() =>
-            client.databases.query({
-              database_id: options.database,
-              start_cursor: cursor,
-            })
-          )
+          queryDatabase(client, cursor)
         );
         const built = await Promise.all(
           pages.map((page) => toEntry(client, page))

package/src/core/sources/types.ts

@@ -106,6 +106,8 @@ export interface ContentSource {
 /** Context passed to `normalizeEntry`, describing the owning source. */
 export interface NormalizeContext {
   source: { name: string; prefix?: string; staged: boolean };
+  /** Site-wide route mount point (`""` or `/seg`), prepended to every route. */
+  basePath?: string;
   defaultType: string;
   i18n?: ResolvedI18nConfig;
 }

package/src/core/tsconfig-aliases.ts

@@ -21,38 +21,65 @@ import { dirname, isAbsolute, join, resolve } from "pathe";
  * aliases (the prior behavior).
  */
 
+interface ScanStep {
+  append: string;
+  inString: boolean;
+  next: number;
+}
+
+/** Scan one character (or comment/escape run) starting at `index`. */
+const scanJsonChar = (
+  text: string,
+  index: number,
+  inString: boolean
+): ScanStep => {
+  const char = text[index];
+  if (inString) {
+    if (char === "\\") {
+      return {
+        append: char + (text[index + 1] ?? ""),
+        inString: true,
+        next: index + 2,
+      };
+    }
+    return { append: char ?? "", inString: char !== '"', next: index + 1 };
+  }
+  if (char === '"') {
+    return { append: char, inString: true, next: index + 1 };
+  }
+  if (char === "/" && text[index + 1] === "/") {
+    const newline = text.indexOf("\n", index + 2);
+    return {
+      append: "",
+      inString: false,
+      next: newline === -1 ? text.length : newline,
+    };
+  }
+  if (char === "/" && text[index + 1] === "*") {
+    const end = text.indexOf("*/", index + 2);
+    return {
+      append: "",
+      inString: false,
+      next: end === -1 ? text.length : end + 2,
+    };
+  }
+  return { append: char ?? "", inString: false, next: index + 1 };
+};
+
 /** Strip `//` line and `/* *\/` block comments that sit outside strings. */
 const stripJsonComments = (text: string): string => {
   let out = "";
   let inString = false;
-  for (let index = 0; index < text.length; index += 1) {
-    const char = text[index];
-    if (inString) {
-      out += char;
-      if (char === "\\") {
-        out += text[index + 1] ?? "";
-        index += 1;
-      } else if (char === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      out += char;
-      continue;
-    }
-    if (char === "/" && text[index + 1] === "/") {
-      const newline = text.indexOf("\n", index + 2);
-      index = newline === -1 ? text.length : newline - 1;
-      continue;
-    }
-    if (char === "/" && text[index + 1] === "*") {
-      const end = text.indexOf("*/", index + 2);
-      index = end === -1 ? text.length : end + 1;
-      continue;
-    }
-    out += char;
+  let index = 0;
+  while (index < text.length) {
+    const {
+      append,
+      inString: nextInString,
+      next,
+    } = scanJsonChar(text, index, inString);
+    out += append;
+    inString = nextInString;
+    index = next;
   }
   return out;
 };
@@ -97,10 +124,12 @@ const resolveExtends = (spec: string, fromDir: string): string | null => {
   }
   // A bare specifier points at a package's shared config (e.g. `@tsconfig/*`).
   try {
-    const require_ = createRequire(pathToFileURL(join(fromDir, "_.js")).href);
+    const requireFromDir = createRequire(
+      pathToFileURL(join(fromDir, "_.js")).href
+    );
     for (const sub of [`${spec}/tsconfig.json`, spec]) {
       try {
-        return require_.resolve(sub);
+        return requireFromDir.resolve(sub);
       } catch {
         // try the next candidate
       }

package/src/core/types.ts

@@ -173,10 +173,15 @@ export interface NavSelectorItem {
   tag?: string;
 }
 
+/** Context-partition selector kinds (a versioned/localized/multi-product site). */
+type NavSelectorContextKind = "product" | "version";
+/** What a top-level partition selector switches between. */
+type NavSelectorKind = "dropdown" | "language" | NavSelectorContextKind;
+
 /** Top-level partition selectors (products, versions, languages). */
 export interface NavSelector {
   label: string;
-  kind: "dropdown" | "language" | "product" | "version";
+  kind: NavSelectorKind;
   items: NavSelectorItem[];
 }
 

package/src/deploy/redirects.ts

@@ -1,3 +1,4 @@
+import { withBasePath } from "../core/base-path.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
 
 /**
@@ -10,6 +11,23 @@ import type { ResolvedConfig } from "../core/schema.ts";
 
 type Redirect = ResolvedConfig["redirects"][number];
 
+/**
+ * Prepend the site-wide `basePath` to each redirect's internal `from`/`to`
+ * (both are authored as if mounted at root); external `to` URLs pass through.
+ * Idempotent, so re-basing an already-based redirect is safe.
+ */
+export const applyBaseToRedirects = (
+  redirects: Redirect[],
+  basePath: string
+): Redirect[] =>
+  basePath
+    ? redirects.map((redirect) => ({
+        ...redirect,
+        from: withBasePath(basePath, redirect.from),
+        to: withBasePath(basePath, redirect.to),
+      }))
+    : redirects;
+
 /** `_redirects` text (Netlify + Cloudflare Pages): `from to status` per line. */
 export const buildNetlifyRedirects = (redirects: Redirect[]): string =>
   `${redirects

package/src/deploy/robots.ts

@@ -1,3 +1,4 @@
+import { normalizeBasePath, withBasePath } from "../core/base-path.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import type { ContentSignalPolicy, ContentSignals } from "../core/schema.ts";
 
@@ -47,7 +48,11 @@ export const buildRobots = (project: BlumeProject): string | null => {
 
   const { site } = config.deployment;
   if (site && config.seo.sitemap) {
-    lines.push("", `Sitemap: ${site.replace(/\/$/u, "")}/sitemap.xml`);
+    const sitemapPath = withBasePath(
+      normalizeBasePath(config.deployment.base),
+      "/sitemap.xml"
+    );
+    lines.push("", `Sitemap: ${site.replace(/\/$/u, "")}${sitemapPath}`);
   }
   return `${lines.join("\n")}\n`;
 };