blume 0.5.0 → 0.5.1

package/src/migrate/mintlify/config.ts

@@ -17,8 +17,6 @@ type NavigationSelectorItem = NavigationSelectors[number]["items"][number];
 type NavigationChromeVariants = NonNullable<
   BlumeConfig["navigation"]
 >["chromeVariants"];
-type NavigationSidebarVariants =
-  ResolvedConfig["navigation"]["sidebarVariants"];
 
 const MINTLIFY_DEFAULT_IGNORES = [
   "**/_*",
@@ -307,18 +305,6 @@ const mintlifyBackgroundDecoration = (
   return undefined;
 };
 
-const sidebarItemPaths = (items: SidebarItemConfig[]): string[] =>
-  items.flatMap((item) => {
-    if (typeof item === "string") {
-      return [tabPathFromRef(item)];
-    }
-    if (item.href) {
-      return [item.href];
-    }
-    const paths = item.root ? [tabPathFromRef(item.root)] : [];
-    return item.items ? [...paths, ...sidebarItemPaths(item.items)] : paths;
-  });
-
 const collapsedFromExpanded = (value: unknown): boolean | undefined => {
   if (value === false) {
     return true;
@@ -439,79 +425,6 @@ const isExternalRoute = (path: string): boolean =>
   path.startsWith("mailto:") ||
   path.startsWith("tel:");
 
-const hasOwnNavigationContent = (item: JsonObject): boolean =>
-  Boolean(asString(item.root)) || childItemsFor(item).length > 0;
-
-const mintlifySidebarVariants = async (
-  spec: JsonObject
-): Promise<NavigationSidebarVariants> => {
-  const navigation = asObject(spec.navigation) ?? {};
-  const global = asObject(navigation.global) ?? {};
-  interface SidebarVariantCandidate {
-    item: unknown;
-    path: string;
-  }
-  const candidates: SidebarVariantCandidate[] = [];
-
-  const addCandidate = (item: unknown): void => {
-    const path = navItemPath(item);
-    if (!path || isExternalRoute(path)) {
-      return;
-    }
-
-    candidates.push({ item, path });
-  };
-
-  for (const item of [
-    ...asArray(navigation.tabs),
-    ...asArray(navigation.anchors),
-    ...asArray(global.anchors),
-  ]) {
-    const object = asObject(item);
-    if (!object) {
-      addCandidate(item);
-      continue;
-    }
-
-    for (const menuItem of asArray(object.menu)) {
-      addCandidate(menuItem);
-    }
-
-    if (hasOwnNavigationContent(object)) {
-      addCandidate(item);
-    }
-  }
-
-  for (const item of [
-    ...asArray(navigation.dropdowns),
-    ...asArray(navigation.products),
-    ...asArray(navigation.versions),
-    ...asArray(navigation.languages),
-  ]) {
-    addCandidate(item);
-  }
-
-  const resolved = await Promise.all(
-    candidates.map(async (candidate) => {
-      const items = await toSidebarItems([candidate.item], {});
-      if (items.length === 0) {
-        return [];
-      }
-      return [candidate.path, ...sidebarItemPaths(items)]
-        .filter((path) => !isExternalRoute(path))
-        .map((path) => ({ items, path }));
-    })
-  );
-  const seen = new Set<string>();
-  return resolved.flat().flatMap((variant) => {
-    if (!variant || seen.has(variant.path)) {
-      return [];
-    }
-    seen.add(variant.path);
-    return [variant];
-  });
-};
-
 const mintlifyTabs = (
   spec: JsonObject
 ): NonNullable<BlumeConfig["navigation"]>["tabs"] => {
@@ -604,24 +517,53 @@ const toAstroRedirectPath = (path: string): string =>
     modifier === "*" || modifier === "+" ? `[...${name}]` : `[${name}]`
   );
 
-const mintlifyRedirects = (
+// A converted path is dynamic once it holds an Astro segment (`[id]`/`[...slug]`
+// from a `:param`). Blume redirects are static path-to-path: a dynamic segment
+// has no matching route, so Astro aborts the build ("destination does not match
+// any existing route"), and the platform redirect files emit the segment
+// verbatim, which no host understands. Such redirects are dropped, not emitted.
+const isDynamicRedirectPath = (path: string): boolean => path.includes("[");
+
+export interface MintlifyRedirectPartition {
+  /** Static redirects Blume can honor, translated to Blume's `from`/`to` shape. */
+  kept: NonNullable<BlumeConfig["redirects"]>;
+  /** Source paths of dynamic redirects dropped because Blume can't model them. */
+  dropped: string[];
+}
+
+/**
+ * Split a spec's redirects into the static ones Blume emits and the dynamic
+ * (wildcard/param) ones it drops. Keeping a dynamic redirect crashes the Astro
+ * build, so the migrator surfaces the dropped sources as a warning instead.
+ */
+export const partitionMintlifyRedirects = (
   spec: JsonObject
-): NonNullable<BlumeConfig["redirects"]> =>
-  asArray(spec.redirects).flatMap((redirect) => {
+): MintlifyRedirectPartition => {
+  const kept: NonNullable<BlumeConfig["redirects"]> = [];
+  const dropped: string[] = [];
+  for (const redirect of asArray(spec.redirects)) {
     const object = asObject(redirect);
     if (!object) {
-      return [];
+      continue;
     }
-    const from = asString(object.source) ?? asString(object.from);
-    const to =
+    const source = asString(object.source) ?? asString(object.from);
+    const destination =
       asString(object.destination) ??
       asString(object.to) ??
       asString(object.redirect);
-    if (!from || !to) {
-      return [];
+    if (!source || !destination) {
+      continue;
     }
-    return [{ from: toAstroRedirectPath(from), to: toAstroRedirectPath(to) }];
-  });
+    const from = toAstroRedirectPath(source);
+    const to = toAstroRedirectPath(destination);
+    if (isDynamicRedirectPath(from) || isDynamicRedirectPath(to)) {
+      dropped.push(source);
+    } else {
+      kept.push({ from, to });
+    }
+  }
+  return { dropped, kept };
+};
 
 interface OpenApiSourceDraft {
   label?: string;
@@ -981,11 +923,10 @@ export const loadMintlifyConfig = async (
       chromeVariants: mintlifyChromeVariants(spec),
       selectors: mintlifySelectors(spec),
       sidebar: await toSidebarItems(mintlifyNavigationItems(navigation), {}),
-      sidebarVariants: await mintlifySidebarVariants(spec),
       tabs: mintlifyTabs(spec),
     },
     openapi: mintlifyOpenapi(spec),
-    redirects: mintlifyRedirects(spec),
+    redirects: partitionMintlifyRedirects(spec).kept,
     search: {
       indexing: {
         includeHiddenPages: seo.indexing === "all",

package/src/migrate/mintlify/content.ts

@@ -56,6 +56,22 @@ export const rewriteMintlifyExampleBlocks = (source: string): string =>
     "<$<close>CodeGroup"
   );
 
+/**
+ * Mintlify nests `<Accordion title="…">` items inside an `<AccordionGroup>`.
+ * Blume inverts that: `<Accordion>` is the container and each item is an
+ * `<AccordionItem title="…">`. Rewrite both in a single pass — the `\b` after
+ * `Accordion` keeps `<AccordionGroup>` (the `Group` branch) distinct from an
+ * item, so open/close tags of either map correctly regardless of order. Without
+ * this, migrated pages keep `<AccordionGroup>`, which Blume doesn't ship and the
+ * MDX build rejects with "Expected component AccordionGroup to be defined".
+ */
+export const rewriteMintlifyAccordions = (source: string): string =>
+  source.replaceAll(
+    /<(?<close>\/?)Accordion(?<group>Group)?\b/gu,
+    (_match, close: string, group: string | undefined) =>
+      group ? `<${close}Accordion` : `<${close}AccordionItem`
+  );
+
 const SNIPPET_IMPORT =
   /^import\s+[\s\S]*?\s+from\s+["'](?<source>\/snippets\/[^"']+)["'];?[ \t]*\n?/gmu;
 

package/src/migrate/mintlify/index.ts

@@ -6,7 +6,7 @@ import { glob } from "tinyglobby";
 
 import type { BlumeConfig } from "../../core/schema.ts";
 import { assetSegments } from "./assets.ts";
-import { loadMintlifyConfig } from "./config.ts";
+import { loadMintlifyConfig, partitionMintlifyRedirects } from "./config.ts";
 import { mintlifyI18n } from "./i18n.ts";
 import { transformMintlifyContent } from "./transform.ts";
 
@@ -65,6 +65,22 @@ const droppedChromeWarnings = (
   return warnings;
 };
 
+/**
+ * Warn about dynamic (wildcard/param) redirects the migrator dropped. Blume
+ * redirects are static path-to-path, so a `:slug*`/`:id` source becomes an
+ * unroutable Astro destination — kept ones crash the build. Point the user at
+ * host-level rules that do support wildcards.
+ */
+const droppedRedirectWarnings = (spec: Record<string, unknown>): string[] => {
+  const { dropped } = partitionMintlifyRedirects(spec);
+  if (dropped.length === 0) {
+    return [];
+  }
+  return [
+    `Dropped ${dropped.length} dynamic redirect(s) Blume can't model as static path-to-path (${dropped.join(", ")}); re-add them as host-level rules (e.g. _redirects or vercel.json).`,
+  ];
+};
+
 /** Recursively drop `undefined`, empty arrays, and empty objects. */
 const prune = (value: unknown): unknown => {
   if (Array.isArray(value)) {
@@ -247,6 +263,7 @@ export const migrateMintlifyProject = async (
       );
     }
     warnings.push(...droppedChromeWarnings(spec, config));
+    warnings.push(...droppedRedirectWarnings(spec));
   } else {
     warnings.push("No docs.json or mint.json found; writing a default config.");
     config = { content: { root: "." }, title: "Documentation" };

package/src/migrate/mintlify/transform.ts

@@ -1,6 +1,7 @@
 import matter from "../../core/frontmatter.ts";
 import { stripUnknownPageMeta } from "../shared.ts";
 import {
+  rewriteMintlifyAccordions,
   rewriteMintlifyCallouts,
   rewriteMintlifyExampleBlocks,
   rewriteSnippetImports,
@@ -59,6 +60,7 @@ export const transformMintlifyContent = async (
   text = snippetImports.source;
   text = rewriteMintlifySvgIconProps(text);
   text = rewriteMintlifyExampleBlocks(text);
+  text = rewriteMintlifyAccordions(text);
   text = rewriteMintlifyCallouts(text);
 
   const unsupported = unsupportedMintlifyComponents(text);