astro 2.9.0 → 2.9.1

package/components/ViewTransitions.astro

@@ -47,6 +47,19 @@ const { fallback = 'animate' } = Astro.props as Props;
 		doc.documentElement.dataset.astroTransition = dir;
 		const swap = () => document.documentElement.replaceWith(doc.documentElement);
 
+		// Wait on links to finish, to prevent FOUC
+		const links = Array.from(doc.querySelectorAll('head link[rel=stylesheet]')).map(
+			(link) =>
+				new Promise((resolve) => {
+					const c = link.cloneNode();
+					['load', 'error'].forEach((evName) => c.addEventListener(evName, resolve));
+					document.head.append(c);
+				})
+		);
+		if (links.length) {
+			await Promise.all(links);
+		}
+
 		if (fallback === 'animate') {
 			let isAnimating = false;
 			addEventListener('animationstart', () => (isAnimating = true), { once: true });
@@ -128,7 +141,12 @@ const { fallback = 'animate' } = Astro.props as Props;
 			}
 		});
 		window.addEventListener('popstate', () => {
-			if (!transitionEnabledOnThisPage()) return;
+			if (!transitionEnabledOnThisPage()) {
+				// The current page doesn't haven't View Transitions,
+				// respect that with a full page reload
+				location.reload();
+				return;
+			}
 			const nextIndex = history.state?.index ?? currentHistoryIndex + 1;
 			const direction: Direction = nextIndex > currentHistoryIndex ? 'forward' : 'back';
 			navigate(direction, location.href);

package/components/viewtransitions.css

@@ -42,3 +42,15 @@
 		transform: translateX(-100%);
 	}
 }
+
+@media (prefers-reduced-motion) {
+	::view-transition-group(*),
+	::view-transition-old(*),
+	::view-transition-new(*) {
+		animation: none !important;
+	}
+
+	[data-astro-transition-scope] {
+		animation: none !important;
+	}
+}

package/dist/@types/astro.d.ts

@@ -1173,7 +1173,7 @@ export interface AstroUserConfig {
          * @version 2.9.0
          * @description
          * Enable experimental support for the `<ViewTransitions / >` component. With this enabled
-         * you can opt-in to  [client-side routing](https://docs.astro.build/en/guides/client-side-routing/) on a per-page basis using this component
+         * you can opt-in to [view transitions](https://docs.astro.build/en/guides/view-transitions/) on a per-page basis using this component
          * and enable animations with the `transition:animate` directive.
          *
          * ```js

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.9.0";
+const ASTRO_VERSION = "2.9.1";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/dev.js

@@ -54,7 +54,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.9.0";
+  const currentVersion = "2.9.1";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.9.0";
+  const version = "2.9.1";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.9.0"}`
+        `v${"2.9.1"}`
       )} ${headline}`
     );
   }

package/dist/runtime/server/jsx.js

@@ -77,7 +77,11 @@ Did you forget to import the component or is it possible there is a typo?`);
             props[key] = value;
           }
         }
-        const html = markHTMLString(await renderToString(result, vnode.type, props, slots));
+        const str = await renderToString(result, vnode.type, props, slots);
+        if (str instanceof Response) {
+          throw str;
+        }
+        const html = markHTMLString(str);
         return html;
       }
       case (!vnode.type && vnode.type !== 0):

package/dist/runtime/server/render/astro/factory.d.ts

@@ -9,5 +9,4 @@ export interface AstroComponentFactory {
     propagation?: PropagationHint;
 }
 export declare function isAstroComponentFactory(obj: any): obj is AstroComponentFactory;
-export declare function renderToString(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any): Promise<string>;
 export declare function isAPropagatingComponent(result: SSRResult, factory: AstroComponentFactory): boolean;

package/dist/runtime/server/render/astro/factory.js

@@ -1,22 +1,6 @@
-import { HTMLParts } from "../common.js";
-import { isHeadAndContent } from "./head-and-content.js";
-import { renderAstroTemplateResult } from "./render-template.js";
 function isAstroComponentFactory(obj) {
   return obj == null ? false : obj.isAstroComponentFactory === true;
 }
-async function renderToString(result, componentFactory, props, children) {
-  const factoryResult = await componentFactory(result, props, children);
-  if (factoryResult instanceof Response) {
-    const response = factoryResult;
-    throw response;
-  }
-  let parts = new HTMLParts();
-  const templateResult = isHeadAndContent(factoryResult) ? factoryResult.content : factoryResult;
-  for await (const chunk of renderAstroTemplateResult(templateResult)) {
-    parts.append(chunk, result);
-  }
-  return parts.toString();
-}
 function isAPropagatingComponent(result, factory) {
   let hint = factory.propagation || "none";
   if (factory.moduleId && result.componentMetadata.has(factory.moduleId) && hint === "none") {
@@ -26,6 +10,5 @@ function isAPropagatingComponent(result, factory) {
 }
 export {
   isAPropagatingComponent,
-  isAstroComponentFactory,
-  renderToString
+  isAstroComponentFactory
 };

package/dist/runtime/server/render/astro/index.d.ts

@@ -1,6 +1,7 @@
 export type { AstroComponentFactory } from './factory';
-export { isAstroComponentFactory, renderToString } from './factory.js';
+export { isAstroComponentFactory } from './factory.js';
 export { createHeadAndContent, isHeadAndContent } from './head-and-content.js';
 export type { AstroComponentInstance } from './instance';
 export { createAstroComponentInstance, isAstroComponentInstance } from './instance.js';
 export { isRenderTemplateResult, renderAstroTemplateResult, renderTemplate, } from './render-template.js';
+export { renderToReadableStream, renderToString } from './render.js';

package/dist/runtime/server/render/astro/index.js

@@ -1,4 +1,4 @@
-import { isAstroComponentFactory, renderToString } from "./factory.js";
+import { isAstroComponentFactory } from "./factory.js";
 import { createHeadAndContent, isHeadAndContent } from "./head-and-content.js";
 import { createAstroComponentInstance, isAstroComponentInstance } from "./instance.js";
 import {
@@ -6,6 +6,7 @@ import {
   renderAstroTemplateResult,
   renderTemplate
 } from "./render-template.js";
+import { renderToReadableStream, renderToString } from "./render.js";
 export {
   createAstroComponentInstance,
   createHeadAndContent,
@@ -15,5 +16,6 @@ export {
   isRenderTemplateResult,
   renderAstroTemplateResult,
   renderTemplate,
+  renderToReadableStream,
   renderToString
 };

package/dist/runtime/server/render/astro/render.d.ts

@@ -0,0 +1,4 @@
+import type { RouteData, SSRResult } from '../../../../@types/astro';
+import type { AstroComponentFactory } from './factory.js';
+export declare function renderToString(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any, isPage?: boolean, route?: RouteData): Promise<string | Response>;
+export declare function renderToReadableStream(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any, isPage?: boolean, route?: RouteData): Promise<ReadableStream | Response>;

package/dist/runtime/server/render/astro/render.js

@@ -0,0 +1,119 @@
+import { AstroError, AstroErrorData } from "../../../../core/errors/index.js";
+import { chunkToByteArray, chunkToString, encoder } from "../common.js";
+import { isHeadAndContent } from "./head-and-content.js";
+import { isRenderTemplateResult, renderAstroTemplateResult } from "./render-template.js";
+async function renderToString(result, componentFactory, props, children, isPage = false, route) {
+  const templateResult = await callComponentAsTemplateResultOrResponse(
+    result,
+    componentFactory,
+    props,
+    children,
+    route
+  );
+  if (templateResult instanceof Response)
+    return templateResult;
+  let str = "";
+  let renderedFirstPageChunk = false;
+  const destination = {
+    write(chunk) {
+      if (isPage && !renderedFirstPageChunk) {
+        renderedFirstPageChunk = true;
+        if (!/<!doctype html/i.test(String(chunk))) {
+          const doctype = result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n";
+          str += doctype;
+        }
+      }
+      if (chunk instanceof Response)
+        return;
+      str += chunkToString(result, chunk);
+    }
+  };
+  for await (const chunk of renderAstroTemplateResult(templateResult)) {
+    destination.write(chunk);
+  }
+  return str;
+}
+async function renderToReadableStream(result, componentFactory, props, children, isPage = false, route) {
+  const templateResult = await callComponentAsTemplateResultOrResponse(
+    result,
+    componentFactory,
+    props,
+    children,
+    route
+  );
+  if (templateResult instanceof Response)
+    return templateResult;
+  if (isPage) {
+    await bufferHeadContent(result);
+  }
+  let renderedFirstPageChunk = false;
+  return new ReadableStream({
+    start(controller) {
+      const destination = {
+        write(chunk) {
+          if (isPage && !renderedFirstPageChunk) {
+            renderedFirstPageChunk = true;
+            if (!/<!doctype html/i.test(String(chunk))) {
+              const doctype = result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n";
+              controller.enqueue(encoder.encode(doctype));
+            }
+          }
+          if (chunk instanceof Response) {
+            throw new AstroError({
+              ...AstroErrorData.ResponseSentError
+            });
+          }
+          const bytes = chunkToByteArray(result, chunk);
+          controller.enqueue(bytes);
+        }
+      };
+      (async () => {
+        try {
+          for await (const chunk of renderAstroTemplateResult(templateResult)) {
+            destination.write(chunk);
+          }
+          controller.close();
+        } catch (e) {
+          if (AstroError.is(e) && !e.loc) {
+            e.setLocation({
+              file: route == null ? void 0 : route.component
+            });
+          }
+          controller.error(e);
+        }
+      })();
+    }
+  });
+}
+async function callComponentAsTemplateResultOrResponse(result, componentFactory, props, children, route) {
+  const factoryResult = await componentFactory(result, props, children);
+  if (factoryResult instanceof Response) {
+    return factoryResult;
+  } else if (!isRenderTemplateResult(factoryResult)) {
+    throw new AstroError({
+      ...AstroErrorData.OnlyResponseCanBeReturned,
+      message: AstroErrorData.OnlyResponseCanBeReturned.message(route == null ? void 0 : route.route, typeof factoryResult),
+      location: {
+        file: route == null ? void 0 : route.component
+      }
+    });
+  }
+  return isHeadAndContent(factoryResult) ? factoryResult.content : factoryResult;
+}
+async function bufferHeadContent(result) {
+  const iterator = result._metadata.propagators.values();
+  while (true) {
+    const { value, done } = iterator.next();
+    if (done) {
+      break;
+    }
+    const returnValue = await value.init(result);
+    if (isHeadAndContent(returnValue)) {
+      result._metadata.extraHead.push(returnValue.head);
+    }
+  }
+}
+export {
+  renderToReadableStream,
+  renderToString
+};

package/dist/runtime/server/render/common.d.ts

@@ -2,6 +2,13 @@ import type { SSRResult } from '../../../@types/astro';
 import type { RenderInstruction } from './types.js';
 import { HTMLBytes } from '../escape.js';
 import { type SlotString } from './slot.js';
+export interface RenderDestination {
+    /**
+     * Any rendering logic should call this to construct the HTML output.
+     * See the `chunk` parameter for possible writable values
+     */
+    write(chunk: string | HTMLBytes | RenderInstruction | Response): void;
+}
 export declare const Fragment: unique symbol;
 export declare const Renderer: unique symbol;
 export declare const encoder: TextEncoder;
@@ -14,4 +21,5 @@ export declare class HTMLParts {
     toString(): string;
     toArrayBuffer(): Uint8Array;
 }
+export declare function chunkToString(result: SSRResult, chunk: string | HTMLBytes | RenderInstruction): string;
 export declare function chunkToByteArray(result: SSRResult, chunk: string | HTMLBytes | RenderInstruction): Uint8Array;

package/dist/runtime/server/render/common.js

@@ -78,18 +78,26 @@ class HTMLParts {
     return encoder.encode(this.parts);
   }
 }
+function chunkToString(result, chunk) {
+  if (ArrayBuffer.isView(chunk)) {
+    return decoder.decode(chunk);
+  } else {
+    return stringifyChunk(result, chunk);
+  }
+}
 function chunkToByteArray(result, chunk) {
-  if (chunk instanceof Uint8Array) {
+  if (ArrayBuffer.isView(chunk)) {
     return chunk;
+  } else {
+    return encoder.encode(stringifyChunk(result, chunk));
   }
-  let stringified = stringifyChunk(result, chunk);
-  return encoder.encode(stringified.toString());
 }
 export {
   Fragment,
   HTMLParts,
   Renderer,
   chunkToByteArray,
+  chunkToString,
   decoder,
   encoder,
   stringifyChunk

package/dist/runtime/server/render/page.js

@@ -1,14 +1,9 @@
-import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+import { AstroError } from "../../../core/errors/index.js";
 import { isHTMLString } from "../escape.js";
 import { createResponse } from "../response.js";
-import {
-  isAstroComponentFactory,
-  isAstroComponentInstance,
-  isHeadAndContent,
-  isRenderTemplateResult,
-  renderAstroTemplateResult
-} from "./astro/index.js";
-import { HTMLParts, chunkToByteArray, encoder } from "./common.js";
+import { isAstroComponentFactory, isAstroComponentInstance } from "./astro/index.js";
+import { renderToReadableStream, renderToString } from "./astro/render.js";
+import { HTMLParts, encoder } from "./common.js";
 import { renderComponent } from "./component.js";
 import { maybeRenderHead } from "./head.js";
 const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
@@ -34,19 +29,6 @@ async function iterableToHTMLBytes(result, iterable, onDocTypeInjection) {
   }
   return parts.toArrayBuffer();
 }
-async function bufferHeadContent(result) {
-  const iterator = result._metadata.propagators.values();
-  while (true) {
-    const { value, done } = iterator.next();
-    if (done) {
-      break;
-    }
-    const returnValue = await value.init(result);
-    if (isHeadAndContent(returnValue)) {
-      result._metadata.extraHead.push(returnValue.head);
-    }
-  }
-}
 async function renderPage(result, componentFactory, props, children, streaming, route) {
   var _a, _b;
   if (!isAstroComponentFactory(componentFactory)) {
@@ -93,75 +75,22 @@ async function renderPage(result, componentFactory, props, children, streaming,
     });
   }
   result._metadata.headInTree = ((_b = result.componentMetadata.get(componentFactory.moduleId)) == null ? void 0 : _b.containsHead) ?? false;
-  const factoryReturnValue = await componentFactory(result, props, children);
-  const factoryIsHeadAndContent = isHeadAndContent(factoryReturnValue);
-  if (isRenderTemplateResult(factoryReturnValue) || factoryIsHeadAndContent) {
-    await bufferHeadContent(result);
-    const templateResult = factoryIsHeadAndContent ? factoryReturnValue.content : factoryReturnValue;
-    let iterable = renderAstroTemplateResult(templateResult);
-    let init = result.response;
-    let headers = new Headers(init.headers);
-    let body;
-    if (streaming) {
-      body = new ReadableStream({
-        start(controller) {
-          async function read() {
-            let i = 0;
-            try {
-              for await (const chunk of iterable) {
-                if (isHTMLString(chunk)) {
-                  if (i === 0) {
-                    if (!/<!doctype html/i.test(String(chunk))) {
-                      controller.enqueue(
-                        encoder.encode(
-                          `${result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n"}`
-                        )
-                      );
-                    }
-                  }
-                }
-                if (chunk instanceof Response) {
-                  throw new AstroError({
-                    ...AstroErrorData.ResponseSentError
-                  });
-                }
-                const bytes = chunkToByteArray(result, chunk);
-                controller.enqueue(bytes);
-                i++;
-              }
-              controller.close();
-            } catch (e) {
-              if (AstroError.is(e) && !e.loc) {
-                e.setLocation({
-                  file: route == null ? void 0 : route.component
-                });
-              }
-              controller.error(e);
-            }
-          }
-          read();
-        }
-      });
-    } else {
-      body = await iterableToHTMLBytes(result, iterable);
-      headers.set("Content-Length", body.byteLength.toString());
-    }
-    let response = createResponse(body, { ...init, headers });
-    return response;
+  let body;
+  if (streaming) {
+    body = await renderToReadableStream(result, componentFactory, props, children, true, route);
+  } else {
+    body = await renderToString(result, componentFactory, props, children, true, route);
   }
-  if (!(factoryReturnValue instanceof Response)) {
-    throw new AstroError({
-      ...AstroErrorData.OnlyResponseCanBeReturned,
-      message: AstroErrorData.OnlyResponseCanBeReturned.message(
-        route == null ? void 0 : route.route,
-        typeof factoryReturnValue
-      ),
-      location: {
-        file: route == null ? void 0 : route.component
-      }
-    });
+  if (body instanceof Response)
+    return body;
+  const init = result.response;
+  const headers = new Headers(init.headers);
+  if (!streaming && typeof body === "string") {
+    body = encoder.encode(body);
+    headers.set("Content-Length", body.byteLength.toString());
   }
-  return factoryReturnValue;
+  const response = createResponse(body, { ...init, headers });
+  return response;
 }
 export {
   renderPage

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

@@ -118,7 +118,7 @@ function markdown({ settings, logging }) {
 
 				function updateImageReferences(html) {
 					return html.replaceAll(
-						/__ASTRO_IMAGE_="(.+)"/gm,
+						/__ASTRO_IMAGE_="([^"]+)"/gm,
 						(full, imagePath) => spreadAttributes({src: images[imagePath].src, ...images[imagePath].attributes})
 					);
 				}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",