astro 6.4.0 → 6.4.2

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "6.4.0";
+  version = "6.4.2";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

@@ -197,7 +197,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.4.0") {
+    if (previousAstroVersion && previousAstroVersion !== "6.4.2") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -205,8 +205,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.4.0") {
-      this.#store.metaStore().set("astro-version", "6.4.0");
+    if ("6.4.2") {
+      this.#store.metaStore().set("astro-version", "6.4.2");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/core/app/base.js

@@ -151,6 +151,10 @@ class BaseApp {
       return routeData;
     }
     if (routeData.prerender) {
+      if (routeData.params.length > 0) {
+        const allMatches = this.pipeline.matchAllRoutes(decodeURI(pathname));
+        return allMatches.find((r) => !r.prerender);
+      }
       return void 0;
     }
     return routeData;

package/dist/core/base-pipeline.d.ts

@@ -117,6 +117,13 @@ export declare abstract class Pipeline {
      * routes or check public assets — use `BaseApp.match()` for that.
      */
     matchRoute(pathname: string): RouteData | undefined;
+    /**
+     * Returns all routes matching the given pathname, in priority order.
+     * Used when the first match cannot serve the request (e.g. a
+     * prerendered dynamic route that doesn't cover this specific path)
+     * and the caller needs to try subsequent matches.
+     */
+    matchAllRoutes(pathname: string): RouteData[];
     /**
      * Rebuilds the internal router after routes have been added or
      * removed (e.g. by the dev server on HMR).

package/dist/core/base-pipeline.js

@@ -123,6 +123,15 @@ class Pipeline {
     if (match.type !== "match") return void 0;
     return match.route;
   }
+  /**
+   * Returns all routes matching the given pathname, in priority order.
+   * Used when the first match cannot serve the request (e.g. a
+   * prerendered dynamic route that doesn't cover this specific path)
+   * and the caller needs to try subsequent matches.
+   */
+  matchAllRoutes(pathname) {
+    return this.#router.matchAll(pathname, { allowWithoutBase: true });
+  }
   /**
    * Rebuilds the internal router after routes have been added or
    * removed (e.g. by the dev server on HMR).

package/dist/core/config/validate.js

@@ -35,6 +35,7 @@ function warnDeprecatedMarkdownOptions(config) {
 }
 let didWarnAboutLegacyMarkdownPlugins = false;
 let didWarnAboutProcessorMismatch = false;
+const migratedLegacyPluginCounts = /* @__PURE__ */ new WeakMap();
 async function coerceLegacyMarkdownPlugins(config) {
   const md = config?.markdown;
   if (!md) return;
@@ -48,18 +49,24 @@ async function coerceLegacyMarkdownPlugins(config) {
   const current = md.processor;
   if (!current || isUnifiedProcessor(current)) {
     const target = current ?? (md.processor = unified());
-    target.options.remarkPlugins.push(...remarkPlugins);
-    target.options.rehypePlugins.push(...rehypePlugins);
+    const counts = migratedLegacyPluginCounts.get(target.options) ?? { remark: 0, rehype: 0 };
+    if (remarkPlugins.length > counts.remark) {
+      target.options.remarkPlugins.push(...remarkPlugins.slice(counts.remark));
+    }
+    if (rehypePlugins.length > counts.rehype) {
+      target.options.rehypePlugins.push(...rehypePlugins.slice(counts.rehype));
+    }
     Object.assign(target.options.remarkRehype, remarkRehype);
+    migratedLegacyPluginCounts.set(target.options, {
+      remark: remarkPlugins.length,
+      rehype: rehypePlugins.length
+    });
     if (!didWarnAboutLegacyMarkdownPlugins) {
       didWarnAboutLegacyMarkdownPlugins = true;
       console.warn(
         "[astro] `markdown.remarkPlugins`, `markdown.rehypePlugins`, and `markdown.remarkRehype` are deprecated. Pass them to `unified({...})` from `@astrojs/markdown-remark` directly instead."
       );
     }
-    delete md.remarkPlugins;
-    delete md.rehypePlugins;
-    delete md.remarkRehype;
   } else if (!didWarnAboutProcessorMismatch) {
     didWarnAboutProcessorMismatch = true;
     console.warn(

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.4.0";
+const ASTRO_VERSION = "6.4.2";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";

package/dist/core/dev/dev.js

@@ -37,7 +37,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.4.0";
+  const currentVersion = "6.4.2";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/fetch/fetch-state.js

@@ -608,7 +608,12 @@ class FetchState {
     }
     const matched = pipeline.matchRoute(this.pathname);
     if (matched && matched.prerender && pipeline.manifest.serverLike) {
-      this.routeData = void 0;
+      if (matched.params.length > 0) {
+        const allMatches = pipeline.matchAllRoutes(this.pathname);
+        this.routeData = allMatches.find((r) => !r.prerender);
+      } else {
+        this.routeData = void 0;
+      }
     } else {
       this.routeData = matched;
     }

package/dist/core/messages/runtime.js

@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.4.0"}`
+        `v${"6.4.2"}`
       )} ${headline}`
     );
   }

package/dist/core/routing/router.d.ts

@@ -46,5 +46,13 @@ export declare class Router {
     match(inputPathname: string, { allowWithoutBase }?: {
         allowWithoutBase?: boolean;
     }): RouterMatch;
+    /**
+     * Returns all routes that match the given pathname, in priority order.
+     * Used when the first match (e.g. a prerendered route) cannot serve
+     * the request and subsequent matches need to be tried.
+     */
+    matchAll(inputPathname: string, { allowWithoutBase }?: {
+        allowWithoutBase?: boolean;
+    }): RouteData[];
 }
 export {};

package/dist/core/routing/router.js

@@ -57,6 +57,34 @@ class Router {
     const params = getParams(route, pathname);
     return { type: "match", route, params, pathname };
   }
+  /**
+   * Returns all routes that match the given pathname, in priority order.
+   * Used when the first match (e.g. a prerendered route) cannot serve
+   * the request and subsequent matches need to be tried.
+   */
+  matchAll(inputPathname, { allowWithoutBase = false } = {}) {
+    const normalized = getRedirectForPathname(inputPathname);
+    if (normalized.redirect) {
+      return [];
+    }
+    const baseResult = stripBase(
+      normalized.pathname,
+      this.#base,
+      this.#baseWithoutTrailingSlash,
+      this.#trailingSlash
+    );
+    if (!baseResult && !allowWithoutBase) {
+      return [];
+    }
+    let pathname = baseResult ?? normalized.pathname;
+    if (this.#buildFormat === "file") {
+      pathname = normalizeFileFormatPathname(pathname);
+    }
+    return this.#routes.filter((candidate) => {
+      if (candidate.pattern.test(pathname)) return true;
+      return candidate.fallbackRoutes.some((fallbackRoute) => fallbackRoute.pattern.test(pathname));
+    });
+  }
 }
 function normalizeBase(base) {
   if (!base) return "/";

package/dist/jsx/rehype.d.ts

@@ -0,0 +1,5 @@
+import type { RehypePlugin } from '@astrojs/internal-helpers/markdown';
+import type { VFile } from 'vfile';
+import type { PluginMetadata } from '../vite-plugin-astro/types.js';
+export declare const rehypeAnalyzeAstroMetadata: RehypePlugin;
+export declare function getAstroMetadata(file: VFile): PluginMetadata["astro"] | undefined;

package/dist/jsx/rehype.js

@@ -0,0 +1,241 @@
+import { visit } from "unist-util-visit";
+import { AstroError } from "../core/errors/errors.js";
+import { AstroErrorData } from "../core/errors/index.js";
+import { resolvePath } from "../core/viteUtils.js";
+import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
+const ClientOnlyPlaceholder = "astro-client-only";
+const rehypeAnalyzeAstroMetadata = () => {
+  return (tree, file) => {
+    const metadata = createDefaultAstroMetadata();
+    const imports = parseImports(tree.children);
+    visit(tree, (node) => {
+      if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return;
+      const tagName = node.name;
+      if (!tagName || !isComponent(tagName) || !(hasClientDirective(node) || hasServerDeferDirective(node)))
+        return;
+      const matchedImport = findMatchingImport(tagName, imports);
+      if (!matchedImport) {
+        throw new AstroError({
+          ...AstroErrorData.NoMatchingImport,
+          message: AstroErrorData.NoMatchingImport.message(node.name)
+        });
+      }
+      if (matchedImport.path.endsWith(".astro")) {
+        const clientAttribute = node.attributes.find(
+          (attr) => attr.type === "mdxJsxAttribute" && attr.name.startsWith("client:")
+        );
+        if (clientAttribute) {
+          console.warn(
+            `You are attempting to render <${node.name} ${clientAttribute.name} />, but ${node.name} is an Astro component. Astro components do not render in the client and should not have a hydration directive. Please use a framework component for client rendering.`
+          );
+        }
+      }
+      const resolvedPath = resolvePath(matchedImport.path, file.path);
+      if (hasClientOnlyDirective(node)) {
+        metadata.clientOnlyComponents.push({
+          exportName: matchedImport.name,
+          localName: "",
+          specifier: tagName,
+          resolvedPath
+        });
+        addClientOnlyMetadata(node, matchedImport, resolvedPath);
+      } else if (hasClientDirective(node)) {
+        metadata.hydratedComponents.push({
+          exportName: "*",
+          localName: "",
+          specifier: tagName,
+          resolvedPath
+        });
+        addClientMetadata(node, matchedImport, resolvedPath);
+      } else if (hasServerDeferDirective(node)) {
+        metadata.serverComponents.push({
+          exportName: matchedImport.name,
+          localName: tagName,
+          specifier: matchedImport.path,
+          resolvedPath
+        });
+        addServerDeferMetadata(node, matchedImport, resolvedPath);
+      }
+    });
+    file.data.__astroMetadata = metadata;
+  };
+};
+function getAstroMetadata(file) {
+  return file.data.__astroMetadata;
+}
+function parseImports(children) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const child of children) {
+    if (child.type !== "mdxjsEsm") continue;
+    const body = child.data?.estree?.body;
+    if (!body) continue;
+    for (const ast of body) {
+      if (ast.type !== "ImportDeclaration") continue;
+      const source = ast.source.value;
+      const specs = ast.specifiers.map((spec) => {
+        switch (spec.type) {
+          case "ImportDefaultSpecifier":
+            return { local: spec.local.name, imported: "default" };
+          case "ImportNamespaceSpecifier":
+            return { local: spec.local.name, imported: "*" };
+          case "ImportSpecifier": {
+            return {
+              local: spec.local.name,
+              imported: spec.imported.type === "Identifier" ? spec.imported.name : String(spec.imported.value)
+            };
+          }
+          default:
+            throw new Error("Unknown import declaration specifier: " + spec);
+        }
+      });
+      let specSet = imports.get(source);
+      if (!specSet) {
+        specSet = /* @__PURE__ */ new Set();
+        imports.set(source, specSet);
+      }
+      for (const spec of specs) {
+        specSet.add(spec);
+      }
+    }
+  }
+  return imports;
+}
+function isComponent(tagName) {
+  return tagName[0] && tagName[0].toLowerCase() !== tagName[0] || tagName.includes(".") || /[^a-zA-Z]/.test(tagName[0]);
+}
+function hasClientDirective(node) {
+  return node.attributes.some(
+    (attr) => attr.type === "mdxJsxAttribute" && attr.name.startsWith("client:")
+  );
+}
+function hasServerDeferDirective(node) {
+  return node.attributes.some(
+    (attr) => attr.type === "mdxJsxAttribute" && attr.name === "server:defer"
+  );
+}
+function hasClientOnlyDirective(node) {
+  return node.attributes.some(
+    (attr) => attr.type === "mdxJsxAttribute" && attr.name === "client:only"
+  );
+}
+function findMatchingImport(tagName, imports) {
+  const tagSpecifier = tagName.split(".")[0];
+  for (const [source, specs] of imports) {
+    for (const { imported, local } of specs) {
+      if (local === tagSpecifier) {
+        if (tagSpecifier !== tagName) {
+          switch (imported) {
+            // Namespace import: "<buttons.Foo.Bar />" => name: "Foo.Bar"
+            case "*": {
+              const accessPath = tagName.slice(tagSpecifier.length + 1);
+              return { name: accessPath, path: source };
+            }
+            // Default import: "<buttons.Foo.Bar />" => name: "default.Foo.Bar"
+            case "default": {
+              const accessPath = tagName.slice(tagSpecifier.length + 1);
+              return { name: `default.${accessPath}`, path: source };
+            }
+            // Named import: "<buttons.Foo.Bar />" => name: "buttons.Foo.Bar"
+            default: {
+              return { name: tagName, path: source };
+            }
+          }
+        }
+        return { name: imported, path: source };
+      }
+    }
+  }
+}
+function addClientMetadata(node, meta, resolvedPath) {
+  const attributeNames = node.attributes.map((attr) => attr.type === "mdxJsxAttribute" ? attr.name : null).filter(Boolean);
+  if (!attributeNames.includes("client:component-path")) {
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "client:component-path",
+      value: resolvedPath
+    });
+  }
+  if (!attributeNames.includes("client:component-export")) {
+    if (meta.name === "*") {
+      meta.name = node.name.split(".").slice(1).join(".");
+    }
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "client:component-export",
+      value: meta.name
+    });
+  }
+  if (!attributeNames.includes("client:component-hydration")) {
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "client:component-hydration",
+      value: null
+    });
+  }
+}
+function addClientOnlyMetadata(node, meta, resolvedPath) {
+  const attributeNames = node.attributes.map((attr) => attr.type === "mdxJsxAttribute" ? attr.name : null).filter(Boolean);
+  if (!attributeNames.includes("client:display-name")) {
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "client:display-name",
+      value: node.name
+    });
+  }
+  if (!attributeNames.includes("client:component-path")) {
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "client:component-path",
+      value: resolvedPath
+    });
+  }
+  if (!attributeNames.includes("client:component-export")) {
+    if (meta.name === "*") {
+      meta.name = node.name.split(".").slice(1).join(".");
+    }
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "client:component-export",
+      value: meta.name
+    });
+  }
+  if (!attributeNames.includes("client:component-hydration")) {
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "client:component-hydration",
+      value: null
+    });
+  }
+  node.name = ClientOnlyPlaceholder;
+}
+function addServerDeferMetadata(node, meta, resolvedPath) {
+  const attributeNames = node.attributes.map((attr) => attr.type === "mdxJsxAttribute" ? attr.name : null).filter(Boolean);
+  if (!attributeNames.includes("server:component-directive")) {
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "server:component-directive",
+      value: "server:defer"
+    });
+  }
+  if (!attributeNames.includes("server:component-path")) {
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "server:component-path",
+      value: resolvedPath
+    });
+  }
+  if (!attributeNames.includes("server:component-export")) {
+    if (meta.name === "*") {
+      meta.name = node.name.split(".").slice(1).join(".");
+    }
+    node.attributes.push({
+      type: "mdxJsxAttribute",
+      name: "server:component-export",
+      value: meta.name
+    });
+  }
+}
+export {
+  getAstroMetadata,
+  rehypeAnalyzeAstroMetadata
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.4.0",
+  "version": "6.4.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -39,6 +39,7 @@
     "./astro-jsx": "./astro-jsx.d.ts",
     "./tsconfigs/*.json": "./tsconfigs/*",
     "./tsconfigs/*": "./tsconfigs/*.json",
+    "./jsx/rehype.js": "./dist/jsx/rehype.js",
     "./jsx-runtime": {
       "types": "./jsx-runtime.d.ts",
       "default": "./dist/jsx-runtime/index.js"
@@ -188,6 +189,8 @@
     "expect-type": "^1.3.0",
     "fs-fixture": "^2.13.0",
     "hono": "^4.12.14",
+    "mdast-util-mdx": "^3.0.0",
+    "mdast-util-mdx-jsx": "^3.2.0",
     "node-mocks-http": "^1.17.2",
     "parse-srcset": "^1.0.2",
     "rehype-autolink-headings": "^7.1.0",