astro 3.1.0 → 3.1.2

package/dist/events/session.js

@@ -1,63 +1,71 @@
+import { AstroConfigSchema } from "../core/config/schema.js";
 const EVENT_SESSION = "ASTRO_CLI_SESSION_STARTED";
-const multiLevelKeys = /* @__PURE__ */ new Set([
-  "build",
-  "markdown",
-  "markdown.shikiConfig",
-  "server",
-  "vite",
-  "vite.resolve",
-  "vite.css",
-  "vite.json",
-  "vite.server",
-  "vite.server.fs",
-  "vite.build",
-  "vite.preview",
-  "vite.optimizeDeps",
-  "vite.ssr",
-  "vite.worker"
-]);
-function configKeys(obj, parentKey) {
-  if (!obj) {
-    return [];
+function measureIsDefined(val) {
+  if (val === void 0) {
+    return void 0;
   }
-  return Object.entries(obj).map(([key, value]) => {
-    if (typeof value === "object" && !Array.isArray(value)) {
-      const localKey = parentKey ? parentKey + "." + key : key;
-      if (multiLevelKeys.has(localKey)) {
-        let keys = configKeys(value, localKey).map((subkey) => key + "." + subkey);
-        keys.unshift(key);
-        return keys;
-      }
-    }
-    return key;
-  }).flat(1);
+  return Boolean(val);
+}
+function measureStringLiteral(val) {
+  return val;
+}
+function measureIntegration(val) {
+  if (!val || !val.name) {
+    return void 0;
+  }
+  return val.name;
+}
+function sanitizeConfigInfo(obj, validKeys) {
+  if (!obj || validKeys.length === 0) {
+    return {};
+  }
+  return validKeys.reduce(
+    (result, key) => {
+      result[key] = measureIsDefined(obj[key]);
+      return result;
+    },
+    {}
+  );
+}
+function createAnonymousConfigInfo(userConfig) {
+  const configInfo = {
+    ...sanitizeConfigInfo(userConfig, Object.keys(AstroConfigSchema.shape)),
+    build: sanitizeConfigInfo(
+      userConfig.build,
+      Object.keys(AstroConfigSchema.shape.build._def.innerType.shape)
+    ),
+    image: sanitizeConfigInfo(
+      userConfig.image,
+      Object.keys(AstroConfigSchema.shape.image._def.innerType.shape)
+    ),
+    markdown: sanitizeConfigInfo(
+      userConfig.markdown,
+      Object.keys(AstroConfigSchema.shape.markdown._def.innerType.shape)
+    ),
+    experimental: sanitizeConfigInfo(
+      userConfig.experimental,
+      Object.keys(AstroConfigSchema.shape.experimental._def.innerType.shape)
+    ),
+    legacy: sanitizeConfigInfo(
+      userConfig.legacy,
+      Object.keys(AstroConfigSchema.shape.legacy._def.innerType.shape)
+    ),
+    vite: userConfig.vite ? sanitizeConfigInfo(userConfig.vite, Object.keys(userConfig.vite)) : void 0
+  };
+  configInfo.build.format = measureStringLiteral(userConfig.build?.format);
+  configInfo.markdown.syntaxHighlight = measureStringLiteral(userConfig.markdown?.syntaxHighlight);
+  configInfo.output = measureStringLiteral(userConfig.output);
+  configInfo.scopedStyleStrategy = measureStringLiteral(userConfig.scopedStyleStrategy);
+  configInfo.trailingSlash = measureStringLiteral(userConfig.trailingSlash);
+  configInfo.adapter = measureIntegration(userConfig.adapter);
+  configInfo.integrations = userConfig.integrations?.flat(100).map(measureIntegration).filter(Boolean);
+  return configInfo;
 }
 function eventCliSession(cliCommand, userConfig, flags) {
-  const configValues = userConfig ? {
-    markdownPlugins: [
-      ...userConfig?.markdown?.remarkPlugins?.map(
-        (p) => typeof p === "string" ? p : typeof p
-      ) ?? [],
-      ...userConfig?.markdown?.rehypePlugins?.map(
-        (p) => typeof p === "string" ? p : typeof p
-      ) ?? []
-    ],
-    adapter: userConfig?.adapter?.name ?? null,
-    integrations: (userConfig?.integrations ?? []).filter(Boolean).flat().map((i) => i?.name),
-    trailingSlash: userConfig?.trailingSlash,
-    build: userConfig?.build ? {
-      format: userConfig?.build?.format
-    } : void 0,
-    markdown: userConfig?.markdown ? {
-      drafts: userConfig.markdown?.drafts,
-      syntaxHighlight: userConfig.markdown?.syntaxHighlight
-    } : void 0
-  } : void 0;
   const cliFlags = flags ? Object.keys(flags).filter((name) => name != "_") : void 0;
   const payload = {
     cliCommand,
-    configKeys: userConfig ? configKeys(userConfig, "") : void 0,
-    config: configValues,
+    config: createAnonymousConfigInfo(userConfig),
     flags: cliFlags
   };
   return [{ eventName: EVENT_SESSION, payload }];

package/dist/runtime/server/scripts.js

@@ -1,5 +1,5 @@
 import islandScript from "./astro-island.prebuilt.js";
-const ISLAND_STYLES = `<style>astro-island,astro-slot,astro-static-slot{display:contents}</style>`;
+const ISLAND_STYLES = `<style style="display:none">astro-island,astro-slot,astro-static-slot{display:contents}</style>`;
 function determineIfNeedsHydrationScript(result) {
   if (result._metadata.hasHydrationScript) {
     return false;
@@ -24,12 +24,12 @@ function getDirectiveScriptText(result, directive) {
 function getPrescripts(result, type, directive) {
   switch (type) {
     case "both":
-      return `${ISLAND_STYLES}<script>${getDirectiveScriptText(
+      return `${ISLAND_STYLES}<script style="display:none">${getDirectiveScriptText(
         result,
         directive
       )};${islandScript}</script>`;
     case "directive":
-      return `<script>${getDirectiveScriptText(result, directive)}</script>`;
+      return `<script style="display:none">${getDirectiveScriptText(result, directive)}</script>`;
   }
   return "";
 }

package/dist/vite-plugin-astro/hmr.js

@@ -54,7 +54,7 @@ async function handleHotUpdate(ctx, { config, logger, compile, source }) {
       ctx.server.moduleGraph.onFileChange(file2);
     }
   }
-  const mods = ctx.modules.filter((m) => !m.url.endsWith("="));
+  const mods = [...filtered].filter((m) => !m.url.endsWith("="));
   const file = ctx.file.replace(config.root.pathname, "/");
   if (isStyleOnlyChange) {
     logger.info("astro", msg.hmr({ file, style: true }));
@@ -67,14 +67,6 @@ async function handleHotUpdate(ctx, { config, logger, compile, source }) {
       }
     }
   }
-  for (const mod of filtered) {
-    if (mod.id && isAstroScript(mod.id) && mod.file) {
-      const astroMod = ctx.server.moduleGraph.getModuleById(mod.file);
-      if (astroMod) {
-        mods.unshift(astroMod);
-      }
-    }
-  }
   const isSelfAccepting = mods.every((m) => m.isSelfAccepting || m.url.endsWith(".svelte"));
   if (isSelfAccepting) {
     if (/astro\.config\.[cm][jt]s$/.test(file))

package/dist/vite-plugin-config-alias/index.js

@@ -37,7 +37,8 @@ function configAliasVitePlugin({
     return null;
   const plugin = {
     name: "astro:tsconfig-alias",
-    enforce: "pre",
+    // use post to only resolve ids that all other plugins before it can't
+    enforce: "post",
     configResolved(config) {
       patchCreateResolver(config, plugin);
     },
@@ -56,7 +57,7 @@ function configAliasVitePlugin({
   };
   return plugin;
 }
-function patchCreateResolver(config, prePlugin) {
+function patchCreateResolver(config, postPlugin) {
   const _createResolver = config.createResolver;
   config.createResolver = function(...args1) {
     const resolver = _createResolver.apply(config, args1);
@@ -75,14 +76,16 @@ function patchCreateResolver(config, prePlugin) {
         isEntry: false,
         ssr
       };
-      const resolved = await prePlugin.resolveId.apply(fakePluginContext, [
+      const result = await resolver.apply(_createResolver, args2);
+      if (result)
+        return result;
+      const resolved = await postPlugin.resolveId.apply(fakePluginContext, [
         id,
         importer,
         fakeResolveIdOpts
       ]);
       if (resolved)
         return resolved;
-      return resolver.apply(_createResolver, args2);
     };
   };
 }

package/dist/vite-plugin-markdown/index.js

@@ -8,7 +8,8 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { normalizePath } from "vite";
 import { AstroError, AstroErrorData, MarkdownError } from "../core/errors/index.js";
-import { isMarkdownFile, rootRelativePath } from "../core/util.js";
+import { isMarkdownFile } from "../core/util.js";
+import { shorthash } from "../runtime/server/shorthash.js";
 import { escapeViteEnvReferences, getFileInfo } from "../vite-plugin-utils/index.js";
 function safeMatter(source, id) {
   try {
@@ -71,7 +72,8 @@ function markdown({ settings, logger }) {
         for (const imagePath of rawImagePaths.values()) {
           imagePaths.push({
             raw: imagePath,
-            resolved: (await this.resolve(imagePath, id))?.id ?? path.join(path.dirname(id), imagePath)
+            resolved: (await this.resolve(imagePath, id))?.id ?? path.join(path.dirname(id), imagePath),
+            safeName: shorthash(imagePath)
           });
         }
         const { layout } = frontmatter;
@@ -89,36 +91,26 @@ function markdown({ settings, logger }) {
 
 				${layout ? `import Layout from ${JSON.stringify(layout)};` : ""}
 				import { getImage } from "astro:assets";
+				${imagePaths.map((entry) => `import Astro__${entry.safeName} from ${JSON.stringify(entry.raw)};`)}
 
-				export const images = {
-					${imagePaths.map(
-          (entry) => `'${entry.raw}': await getImageSafely((await import("${entry.raw}")).default, "${entry.raw}", "${rootRelativePath(settings.config.root, entry.resolved)}")`
-        )}
-				}
-
-				async function getImageSafely(imageSrc, imagePath, resolvedImagePath) {
-					if (!imageSrc) {
-						throw new AstroError({
-							...AstroErrorData.MarkdownImageNotFound,
-							message: AstroErrorData.MarkdownImageNotFound.message(
-								imagePath,
-								resolvedImagePath
-							),
-							location: { file: "${id}" },
-						});
+				const images = async function() {
+					return {
+						${imagePaths.map((entry) => `"${entry.raw}": await getImage({src: Astro__${entry.safeName}})`).join("\n")}
 					}
-
-					return await getImage({src: imageSrc})
 				}
 
-				function updateImageReferences(html) {
-					return html.replaceAll(
-						/__ASTRO_IMAGE_="([^"]+)"/gm,
-						(full, imagePath) => spreadAttributes({src: images[imagePath].src, ...images[imagePath].attributes})
-					);
+				async function updateImageReferences(html) {
+					return images().then((images) => {
+						return html.replaceAll(/__ASTRO_IMAGE_="([^"]+)"/gm, (full, imagePath) =>
+							spreadAttributes({
+								src: images[imagePath].src,
+								...images[imagePath].attributes,
+							})
+						);
+					});
 				}
 
-				const html = updateImageReferences(${JSON.stringify(html)});
+				const html = await updateImageReferences(${JSON.stringify(html)});
 
 				export const frontmatter = ${JSON.stringify(frontmatter)};
 				export const file = ${JSON.stringify(fileId)};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -161,7 +161,7 @@
     "zod": "3.21.1",
     "@astrojs/internal-helpers": "0.2.0",
     "@astrojs/markdown-remark": "3.2.0",
-    "@astrojs/telemetry": "3.0.1"
+    "@astrojs/telemetry": "3.0.2"
   },
   "optionalDependencies": {
     "sharp": "^0.32.5"