astro 2.9.2 → 2.9.3

package/components/ViewTransitions.astro

@@ -25,6 +25,7 @@ const { fallback = 'animate' } = Astro.props as Props;
 	const supportsViewTransitions = !!document.startViewTransition;
 	const transitionEnabledOnThisPage = () =>
 		!!document.querySelector('[name="astro-view-transitions-enabled"]');
+	const onload = () => document.dispatchEvent(new Event('astro:load'));
 
 	async function getHTML(href: string) {
 		const res = await fetch(href);
@@ -40,6 +41,25 @@ const { fallback = 'animate' } = Astro.props as Props;
 		return 'animate';
 	}
 
+	function runScripts() {
+		let wait = Promise.resolve();
+		for (const script of Array.from(document.scripts)) {
+			const s = document.createElement('script');
+			s.innerHTML = script.innerHTML;
+			for (const attr of script.attributes) {
+				if (attr.name === 'src') {
+					const p = new Promise((r) => {
+						s.onload = r;
+					});
+					wait = wait.then(() => p as any);
+				}
+				s.setAttribute(attr.name, attr.value);
+			}
+			script.replaceWith(s);
+		}
+		return wait;
+	}
+
 	const parser = new DOMParser();
 
 	async function updateDOM(dir: Direction, html: string, fallback?: Fallback) {
@@ -95,6 +115,8 @@ const { fallback = 'animate' } = Astro.props as Props;
 			await finished;
 		} finally {
 			document.documentElement.removeAttribute('data-astro-transition');
+			await runScripts();
+			onload();
 		}
 	}
 
@@ -171,5 +193,6 @@ const { fallback = 'animate' } = Astro.props as Props;
 				{ passive: true, capture: true }
 			);
 		});
+		addEventListener('load', onload);
 	}
 </script>

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.9.2";
+const ASTRO_VERSION = "2.9.3";
 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.2";
+  const currentVersion = "2.9.3";
   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.2";
+  const version = "2.9.3";
   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.2"}`
+        `v${"2.9.3"}`
       )} ${headline}`
     );
   }

package/dist/core/render/result.js

@@ -1,9 +1,6 @@
-import { isHTMLString } from "../../runtime/server/escape.js";
-import {
-  renderSlotToString,
-  stringifyChunk
-} from "../../runtime/server/index.js";
+import { renderSlotToString } from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
+import { chunkToString } from "../../runtime/server/render/index.js";
 import { AstroCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { warn } from "../logger/core.js";
@@ -62,7 +59,7 @@ class Slots {
       const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
       const expression = getFunctionExpression(component);
       if (expression) {
-        const slot = async () => isHTMLString(await expression) ? expression : expression(...args);
+        const slot = async () => typeof expression === "function" ? expression(...args) : expression;
         return await renderSlotToString(result, slot).then((res) => {
           return res != null ? String(res) : res;
         });
@@ -74,7 +71,7 @@ class Slots {
       }
     }
     const content = await renderSlotToString(result, this.#slots[name]);
-    const outHTML = stringifyChunk(result, content);
+    const outHTML = chunkToString(result, content);
     return outHTML;
   }
 }

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

@@ -3,7 +3,7 @@ export { createAstro } from './astro-global.js';
 export { renderEndpoint } from './endpoint.js';
 export { escapeHTML, HTMLBytes, HTMLString, isHTMLString, markHTMLString, unescapeHTML, } from './escape.js';
 export { renderJSX } from './jsx.js';
-export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderTemplate as render, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderSlotToString, renderTemplate, renderToString, renderUniqueStylesheet, stringifyChunk, voidElementNames, } from './render/index.js';
+export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderTemplate as render, renderComponent, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderSlotToString, renderTemplate, renderToString, renderUniqueStylesheet, voidElementNames, } from './render/index.js';
 export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
 export { renderTransition } from './transition.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;

package/dist/runtime/server/index.js

@@ -17,9 +17,7 @@ import {
   Fragment,
   maybeRenderHead,
   renderTemplate,
-  renderAstroTemplateResult,
   renderComponent,
-  renderComponentToIterable,
   Renderer,
   renderHead,
   renderHTMLElement,
@@ -30,7 +28,6 @@ import {
   renderTemplate as renderTemplate2,
   renderToString,
   renderUniqueStylesheet,
-  stringifyChunk,
   voidElementNames
 } from "./render/index.js";
 import { renderTransition } from "./transition.js";
@@ -106,9 +103,7 @@ export {
   maybeRenderHead,
   mergeSlots,
   renderTemplate as render,
-  renderAstroTemplateResult as renderAstroComponent,
   renderComponent,
-  renderComponentToIterable,
   renderEndpoint,
   renderHTMLElement,
   renderHead,
@@ -122,7 +117,6 @@ export {
   renderTransition,
   renderUniqueStylesheet,
   spreadAttributes,
-  stringifyChunk,
   unescapeHTML,
   voidElementNames
 };

package/dist/runtime/server/jsx.js

@@ -3,12 +3,11 @@ import {
   HTMLString,
   escapeHTML,
   markHTMLString,
-  renderComponentToIterable,
   renderToString,
   spreadAttributes,
   voidElementNames
 } from "./index.js";
-import { HTMLParts } from "./render/common.js";
+import { renderComponentToString } from "./render/component.js";
 const ClientOnlyPlaceholder = "astro-client-only";
 class Skip {
   constructor(vnode) {
@@ -164,7 +163,7 @@ Did you forget to import the component or is it possible there is a typo?`);
       props[Skip.symbol] = skip;
       let output;
       if (vnode.type === ClientOnlyPlaceholder && vnode.props["client:only"]) {
-        output = await renderComponentToIterable(
+        output = await renderComponentToString(
           result,
           vnode.props["client:display-name"] ?? "",
           null,
@@ -172,7 +171,7 @@ Did you forget to import the component or is it possible there is a typo?`);
           slots
         );
       } else {
-        output = await renderComponentToIterable(
+        output = await renderComponentToString(
           result,
           typeof vnode.type === "function" ? vnode.type.name : vnode.type,
           vnode.type,
@@ -180,15 +179,7 @@ Did you forget to import the component or is it possible there is a typo?`);
           slots
         );
       }
-      if (typeof output !== "string" && Symbol.asyncIterator in output) {
-        let parts = new HTMLParts();
-        for await (const chunk of output) {
-          parts.append(chunk, result);
-        }
-        return markHTMLString(parts.toString());
-      } else {
-        return markHTMLString(output);
-      }
+      return markHTMLString(output);
     }
   }
   return markHTMLString(`${vnode}`);

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

@@ -1 +1,2 @@
-export declare function renderChild(child: any): AsyncIterable<any>;
+import { type RenderDestination } from './common.js';
+export declare function renderChild(destination: RenderDestination, child: any): Promise<void>;

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

@@ -1,40 +1,36 @@
 import { escapeHTML, isHTMLString, markHTMLString } from "../escape.js";
-import {
-  isAstroComponentInstance,
-  isRenderTemplateResult,
-  renderAstroTemplateResult
-} from "./astro/index.js";
+import { isAstroComponentInstance, isRenderTemplateResult } from "./astro/index.js";
+import { isRenderInstance } from "./common.js";
 import { SlotString } from "./slot.js";
-import { bufferIterators } from "./util.js";
-async function* renderChild(child) {
+async function renderChild(destination, child) {
   child = await child;
   if (child instanceof SlotString) {
-    if (child.instructions) {
-      yield* child.instructions;
-    }
-    yield child;
+    destination.write(child);
   } else if (isHTMLString(child)) {
-    yield child;
+    destination.write(child);
   } else if (Array.isArray(child)) {
-    const bufferedIterators = bufferIterators(child.map((c) => renderChild(c)));
-    for (const value of bufferedIterators) {
-      yield markHTMLString(await value);
+    for (const c of child) {
+      await renderChild(destination, c);
     }
   } else if (typeof child === "function") {
-    yield* renderChild(child());
+    await renderChild(destination, child());
   } else if (typeof child === "string") {
-    yield markHTMLString(escapeHTML(child));
+    destination.write(markHTMLString(escapeHTML(child)));
   } else if (!child && child !== 0) {
+  } else if (isRenderInstance(child)) {
+    await child.render(destination);
   } else if (isRenderTemplateResult(child)) {
-    yield* renderAstroTemplateResult(child);
+    await child.render(destination);
   } else if (isAstroComponentInstance(child)) {
-    yield* child.render();
+    await child.render(destination);
   } else if (ArrayBuffer.isView(child)) {
-    yield child;
+    destination.write(child);
   } else if (typeof child === "object" && (Symbol.asyncIterator in child || Symbol.iterator in child)) {
-    yield* child;
+    for await (const value of child) {
+      await renderChild(destination, value);
+    }
   } else {
-    yield child;
+    destination.write(child);
   }
 }
 export {

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

@@ -3,5 +3,5 @@ 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 { isRenderTemplateResult, renderTemplate } from './render-template.js';
 export { renderToReadableStream, renderToString } from './render.js';

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

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

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

@@ -1,6 +1,7 @@
 import type { SSRResult } from '../../../../@types/astro';
 import type { ComponentSlots } from '../slot.js';
 import type { AstroComponentFactory, AstroFactoryReturnValue } from './factory.js';
+import type { RenderDestination } from '../common.js';
 type ComponentProps = Record<string | number, any>;
 declare const astroComponentInstanceSym: unique symbol;
 export declare class AstroComponentInstance {
@@ -12,8 +13,8 @@ export declare class AstroComponentInstance {
     private returnValue;
     constructor(result: SSRResult, props: ComponentProps, slots: ComponentSlots, factory: AstroComponentFactory);
     init(result: SSRResult): Promise<AstroFactoryReturnValue>;
-    render(): AsyncGenerator<any, void, undefined>;
+    render(destination: RenderDestination): Promise<void>;
 }
-export declare function createAstroComponentInstance(result: SSRResult, displayName: string, factory: AstroComponentFactory, props: ComponentProps, slots?: any): AstroComponentInstance;
+export declare function createAstroComponentInstance(result: SSRResult, displayName: string, factory: AstroComponentFactory, props: ComponentProps, slots?: any): Promise<AstroComponentInstance>;
 export declare function isAstroComponentInstance(obj: unknown): obj is AstroComponentInstance;
 export {};

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

@@ -20,7 +20,7 @@ class AstroComponentInstance {
     this.returnValue = this.factory(result, this.props, this.slotValues);
     return this.returnValue;
   }
-  async *render() {
+  async render(destination) {
     if (this.returnValue === void 0) {
       await this.init(this.result);
     }
@@ -29,9 +29,9 @@ class AstroComponentInstance {
       value = await value;
     }
     if (isHeadAndContent(value)) {
-      yield* value.content;
+      await value.content.render(destination);
     } else {
-      yield* renderChild(value);
+      await renderChild(destination, value);
     }
   }
 }
@@ -47,11 +47,15 @@ function validateComponentProps(props, displayName) {
     }
   }
 }
-function createAstroComponentInstance(result, displayName, factory, props, slots = {}) {
+async function createAstroComponentInstance(result, displayName, factory, props, slots = {}) {
   validateComponentProps(props, displayName);
   const instance = new AstroComponentInstance(result, props, slots, factory);
   if (isAPropagatingComponent(result, factory) && !result._metadata.propagators.has(factory)) {
     result._metadata.propagators.set(factory, instance);
+    const returnValue = await instance.init(result);
+    if (isHeadAndContent(returnValue)) {
+      result._metadata.extraHead.push(returnValue.head);
+    }
   }
   return instance;
 }

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

@@ -1,5 +1,4 @@
-import type { RenderInstruction } from '../types';
-import { HTMLBytes } from '../../escape.js';
+import type { RenderDestination } from '../common.js';
 declare const renderTemplateResultSym: unique symbol;
 export declare class RenderTemplateResult {
     [renderTemplateResultSym]: boolean;
@@ -7,9 +6,8 @@ export declare class RenderTemplateResult {
     private expressions;
     private error;
     constructor(htmlParts: TemplateStringsArray, expressions: unknown[]);
-    [Symbol.asyncIterator](): AsyncGenerator<any, void, undefined>;
+    render(destination: RenderDestination): Promise<void>;
 }
 export declare function isRenderTemplateResult(obj: unknown): obj is RenderTemplateResult;
-export declare function renderAstroTemplateResult(component: RenderTemplateResult): AsyncIterable<string | HTMLBytes | RenderInstruction>;
 export declare function renderTemplate(htmlParts: TemplateStringsArray, ...expressions: any[]): RenderTemplateResult;
 export {};

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

@@ -2,7 +2,6 @@ var _a;
 import { markHTMLString } from "../../escape.js";
 import { isPromise } from "../../util.js";
 import { renderChild } from "../any.js";
-import { bufferIterators } from "../util.js";
 const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult");
 class RenderTemplateResult {
   constructor(htmlParts, expressions) {
@@ -21,46 +20,26 @@ class RenderTemplateResult {
       return expression;
     });
   }
-  async *[(_a = renderTemplateResultSym, Symbol.asyncIterator)]() {
-    const { htmlParts, expressions } = this;
-    let iterables = bufferIterators(expressions.map((e) => renderChild(e)));
-    for (let i = 0; i < htmlParts.length; i++) {
-      const html = htmlParts[i];
-      const iterable = iterables[i];
-      yield markHTMLString(html);
-      if (iterable) {
-        yield* iterable;
+  async render(destination) {
+    for (let i = 0; i < this.htmlParts.length; i++) {
+      const html = this.htmlParts[i];
+      const exp = this.expressions[i];
+      destination.write(markHTMLString(html));
+      if (exp || exp === 0) {
+        await renderChild(destination, exp);
       }
     }
   }
 }
+_a = renderTemplateResultSym;
 function isRenderTemplateResult(obj) {
   return typeof obj === "object" && !!obj[renderTemplateResultSym];
 }
-async function* renderAstroTemplateResult(component) {
-  for await (const value of component) {
-    if (value || value === 0) {
-      for await (const chunk of renderChild(value)) {
-        switch (chunk.type) {
-          case "directive": {
-            yield chunk;
-            break;
-          }
-          default: {
-            yield markHTMLString(chunk);
-            break;
-          }
-        }
-      }
-    }
-  }
-}
 function renderTemplate(htmlParts, ...expressions) {
   return new RenderTemplateResult(htmlParts, expressions);
 }
 export {
   RenderTemplateResult,
   isRenderTemplateResult,
-  renderAstroTemplateResult,
   renderTemplate
 };

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

@@ -1,7 +1,7 @@
 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";
+import { isRenderTemplateResult } from "./render-template.js";
 async function renderToString(result, componentFactory, props, children, isPage = false, route) {
   const templateResult = await callComponentAsTemplateResultOrResponse(
     result,
@@ -28,9 +28,7 @@ async function renderToString(result, componentFactory, props, children, isPage
       str += chunkToString(result, chunk);
     }
   };
-  for await (const chunk of renderAstroTemplateResult(templateResult)) {
-    destination.write(chunk);
-  }
+  await templateResult.render(destination);
   return str;
 }
 async function renderToReadableStream(result, componentFactory, props, children, isPage = false, route) {
@@ -43,9 +41,6 @@ async function renderToReadableStream(result, componentFactory, props, children,
   );
   if (templateResult instanceof Response)
     return templateResult;
-  if (isPage) {
-    await bufferHeadContent(result);
-  }
   let renderedFirstPageChunk = false;
   return new ReadableStream({
     start(controller) {
@@ -69,9 +64,7 @@ async function renderToReadableStream(result, componentFactory, props, children,
       };
       (async () => {
         try {
-          for await (const chunk of renderAstroTemplateResult(templateResult)) {
-            destination.write(chunk);
-          }
+          await templateResult.render(destination);
           controller.close();
         } catch (e) {
           if (AstroError.is(e) && !e.loc) {
@@ -79,7 +72,7 @@ async function renderToReadableStream(result, componentFactory, props, children,
               file: route == null ? void 0 : route.component
             });
           }
-          controller.error(e);
+          setTimeout(() => controller.error(e), 0);
         }
       })();
     }
@@ -100,19 +93,6 @@ async function callComponentAsTemplateResultOrResponse(result, componentFactory,
   }
   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

@@ -1,25 +1,29 @@
 import type { SSRResult } from '../../../@types/astro';
 import type { RenderInstruction } from './types.js';
-import { HTMLBytes } from '../escape.js';
+import { HTMLBytes, HTMLString } from '../escape.js';
 import { type SlotString } from './slot.js';
+/**
+ * Possible chunk types to be written to the destination, and it'll
+ * handle stringifying them at the end.
+ *
+ * NOTE: Try to reduce adding new types here. If possible, serialize
+ * the custom types to a string in `renderChild` in `any.ts`.
+ */
+export type RenderDestinationChunk = string | HTMLBytes | HTMLString | SlotString | ArrayBufferView | RenderInstruction | Response;
 export interface RenderDestination {
     /**
      * Any rendering logic should call this to construct the HTML output.
-     * See the `chunk` parameter for possible writable values
+     * See the `chunk` parameter for possible writable values.
      */
-    write(chunk: string | HTMLBytes | RenderInstruction | Response): void;
+    write(chunk: RenderDestinationChunk): void;
+}
+export interface RenderInstance {
+    render(destination: RenderDestination): Promise<void> | void;
 }
 export declare const Fragment: unique symbol;
 export declare const Renderer: unique symbol;
 export declare const encoder: TextEncoder;
 export declare const decoder: TextDecoder;
-export declare function stringifyChunk(result: SSRResult, chunk: string | SlotString | RenderInstruction): string;
-export declare class HTMLParts {
-    parts: string;
-    constructor();
-    append(part: string | HTMLBytes | RenderInstruction, result: SSRResult): void;
-    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;
+export declare function chunkToString(result: SSRResult, chunk: Exclude<RenderDestinationChunk, Response>): string;
+export declare function chunkToByteArray(result: SSRResult, chunk: Exclude<RenderDestinationChunk, Response>): Uint8Array;
+export declare function isRenderInstance(obj: unknown): obj is RenderInstance;

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

@@ -60,24 +60,6 @@ function stringifyChunk(result, chunk) {
     return chunk.toString();
   }
 }
-class HTMLParts {
-  constructor() {
-    this.parts = "";
-  }
-  append(part, result) {
-    if (ArrayBuffer.isView(part)) {
-      this.parts += decoder.decode(part);
-    } else {
-      this.parts += stringifyChunk(result, part);
-    }
-  }
-  toString() {
-    return this.parts;
-  }
-  toArrayBuffer() {
-    return encoder.encode(this.parts);
-  }
-}
 function chunkToString(result, chunk) {
   if (ArrayBuffer.isView(chunk)) {
     return decoder.decode(chunk);
@@ -93,13 +75,15 @@ function chunkToByteArray(result, chunk) {
     return encoder.encode(stringified.toString());
   }
 }
+function isRenderInstance(obj) {
+  return !!obj && typeof obj === "object" && "render" in obj && typeof obj.render === "function";
+}
 export {
   Fragment,
-  HTMLParts,
   Renderer,
   chunkToByteArray,
   chunkToString,
   decoder,
   encoder,
-  stringifyChunk
+  isRenderInstance
 };

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

@@ -1,7 +1,13 @@
-import type { SSRResult } from '../../../@types/astro';
+import type { RouteData, SSRResult } from '../../../@types/astro';
 import type { RenderInstruction } from './types.js';
 import { HTMLBytes } from '../escape.js';
-import { type AstroComponentInstance } from './astro/index.js';
+import { type RenderInstance } from './common.js';
+declare const needsHeadRenderingSymbol: unique symbol;
 export type ComponentIterable = AsyncIterable<string | HTMLBytes | RenderInstruction>;
-export declare function renderComponent(result: SSRResult, displayName: string, Component: unknown, props: Record<string | number, any>, slots?: any): Promise<ComponentIterable> | ComponentIterable | AstroComponentInstance;
-export declare function renderComponentToIterable(result: SSRResult, displayName: string, Component: unknown, props: Record<string | number, any>, slots?: any): Promise<ComponentIterable> | ComponentIterable;
+export declare function renderComponent(result: SSRResult, displayName: string, Component: unknown, props: Record<string | number, any>, slots?: any): Promise<RenderInstance>;
+export declare function renderComponentToString(result: SSRResult, displayName: string, Component: unknown, props: Record<string | number, any>, slots?: any, isPage?: boolean, route?: RouteData): Promise<string>;
+export type NonAstroPageComponent = {
+    name: string;
+    [needsHeadRenderingSymbol]: boolean;
+};
+export {};

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

@@ -7,14 +7,18 @@ import { isPromise } from "../util.js";
 import {
   createAstroComponentInstance,
   isAstroComponentFactory,
-  isAstroComponentInstance,
-  renderAstroTemplateResult,
   renderTemplate
 } from "./astro/index.js";
-import { Fragment, Renderer, stringifyChunk } from "./common.js";
+import {
+  Fragment,
+  Renderer,
+  chunkToString
+} from "./common.js";
 import { componentIsHTMLElement, renderHTMLElement } from "./dom.js";
+import { maybeRenderHead } from "./head.js";
 import { renderSlotToString, renderSlots } from "./slot.js";
 import { formatList, internalSpreadAttributes, renderElement, voidElementNames } from "./util.js";
+const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
 const rendererAliases = /* @__PURE__ */ new Map([["solid", "solid-js"]]);
 function guessRenderers(componentUrl) {
   const extname = componentUrl == null ? void 0 : componentUrl.split(".").pop();
@@ -102,8 +106,17 @@ Did you forget to import the component or is it possible there is a typo?`
       }
     }
     if (!renderer && typeof HTMLElement === "function" && componentIsHTMLElement(Component)) {
-      const output = renderHTMLElement(result, Component, _props, slots);
-      return output;
+      const output = await renderHTMLElement(
+        result,
+        Component,
+        _props,
+        slots
+      );
+      return {
+        render(destination) {
+          destination.write(output);
+        }
+      };
     }
   } else {
     if (metadata.hydrateArgs) {
@@ -199,32 +212,41 @@ If you're still stuck, please open an issue on GitHub or join us at https://astr
   if (!html && typeof Component === "string") {
     const Tag = sanitizeElementName(Component);
     const childSlots = Object.values(children).join("");
-    const iterable = renderAstroTemplateResult(
-      await renderTemplate`<${Tag}${internalSpreadAttributes(props)}${markHTMLString(
-        childSlots === "" && voidElementNames.test(Tag) ? `/>` : `>${childSlots}</${Tag}>`
-      )}`
-    );
+    const renderTemplateResult = renderTemplate`<${Tag}${internalSpreadAttributes(
+      props
+    )}${markHTMLString(
+      childSlots === "" && voidElementNames.test(Tag) ? `/>` : `>${childSlots}</${Tag}>`
+    )}`;
     html = "";
-    for await (const chunk of iterable) {
-      html += chunk;
-    }
+    const destination = {
+      write(chunk) {
+        if (chunk instanceof Response)
+          return;
+        html += chunkToString(result, chunk);
+      }
+    };
+    await renderTemplateResult.render(destination);
   }
   if (!hydration) {
-    return async function* () {
-      var _a2;
-      if (slotInstructions) {
-        yield* slotInstructions;
-      }
-      if (isPage || (renderer == null ? void 0 : renderer.name) === "astro:jsx") {
-        yield html;
-      } else if (html && html.length > 0) {
-        yield markHTMLString(
-          removeStaticAstroSlot(html, ((_a2 = renderer == null ? void 0 : renderer.ssr) == null ? void 0 : _a2.supportsAstroStaticSlot) ?? false)
-        );
-      } else {
-        yield "";
+    return {
+      render(destination) {
+        var _a2;
+        if (slotInstructions) {
+          for (const instruction of slotInstructions) {
+            destination.write(instruction);
+          }
+        }
+        if (isPage || (renderer == null ? void 0 : renderer.name) === "astro:jsx") {
+          destination.write(html);
+        } else if (html && html.length > 0) {
+          destination.write(
+            markHTMLString(
+              removeStaticAstroSlot(html, ((_a2 = renderer == null ? void 0 : renderer.ssr) == null ? void 0 : _a2.supportsAstroStaticSlot) ?? false)
+            )
+          );
+        }
       }
-    }();
+    };
   }
   const astroId = shorthash(
     `<!--${metadata.componentExport.value}:${metadata.componentUrl}-->
@@ -259,14 +281,17 @@ ${serializeProps(
   if (island.children) {
     island.props["await-children"] = "";
   }
-  async function* renderAll() {
-    if (slotInstructions) {
-      yield* slotInstructions;
+  return {
+    render(destination) {
+      if (slotInstructions) {
+        for (const instruction of slotInstructions) {
+          destination.write(instruction);
+        }
+      }
+      destination.write({ type: "directive", hydration });
+      destination.write(markHTMLString(renderElement("astro-island", island, false)));
     }
-    yield { type: "directive", hydration, result };
-    yield markHTMLString(renderElement("astro-island", island, false));
-  }
-  return renderAll();
+  };
 }
 function sanitizeElementName(tag) {
   const unsafe = /[&<>'"\s]+/g;
@@ -276,42 +301,94 @@ function sanitizeElementName(tag) {
 }
 async function renderFragmentComponent(result, slots = {}) {
   const children = await renderSlotToString(result, slots == null ? void 0 : slots.default);
-  if (children == null) {
-    return children;
-  }
-  return markHTMLString(children);
+  return {
+    render(destination) {
+      if (children == null)
+        return;
+      destination.write(children);
+    }
+  };
 }
 async function renderHTMLComponent(result, Component, _props, slots = {}) {
   const { slotInstructions, children } = await renderSlots(result, slots);
   const html = Component({ slots: children });
-  const hydrationHtml = slotInstructions ? slotInstructions.map((instr) => stringifyChunk(result, instr)).join("") : "";
-  return markHTMLString(hydrationHtml + html);
+  const hydrationHtml = slotInstructions ? slotInstructions.map((instr) => chunkToString(result, instr)).join("") : "";
+  return {
+    render(destination) {
+      destination.write(markHTMLString(hydrationHtml + html));
+    }
+  };
+}
+async function renderAstroComponent(result, displayName, Component, props, slots = {}) {
+  const instance = await createAstroComponentInstance(result, displayName, Component, props, slots);
+  const chunks = [];
+  const temporaryDestination = {
+    write: (chunk) => chunks.push(chunk)
+  };
+  await instance.render(temporaryDestination);
+  return {
+    render(destination) {
+      for (const chunk of chunks) {
+        destination.write(chunk);
+      }
+    }
+  };
 }
-function renderComponent(result, displayName, Component, props, slots = {}) {
+async function renderComponent(result, displayName, Component, props, slots = {}) {
   if (isPromise(Component)) {
-    return Promise.resolve(Component).then((Unwrapped) => {
-      return renderComponent(result, displayName, Unwrapped, props, slots);
-    });
+    Component = await Component;
   }
   if (isFragmentComponent(Component)) {
-    return renderFragmentComponent(result, slots);
+    return await renderFragmentComponent(result, slots);
   }
   if (isHTMLComponent(Component)) {
-    return renderHTMLComponent(result, Component, props, slots);
+    return await renderHTMLComponent(result, Component, props, slots);
   }
   if (isAstroComponentFactory(Component)) {
-    return createAstroComponentInstance(result, displayName, Component, props, slots);
+    return await renderAstroComponent(result, displayName, Component, props, slots);
   }
-  return renderFrameworkComponent(result, displayName, Component, props, slots);
+  return await renderFrameworkComponent(result, displayName, Component, props, slots);
 }
-function renderComponentToIterable(result, displayName, Component, props, slots = {}) {
-  const renderResult = renderComponent(result, displayName, Component, props, slots);
-  if (isAstroComponentInstance(renderResult)) {
-    return renderResult.render();
+async function renderComponentToString(result, displayName, Component, props, slots = {}, isPage = false, route) {
+  let str = "";
+  let renderedFirstPageChunk = false;
+  let head = "";
+  if (nonAstroPageNeedsHeadInjection(Component)) {
+    for (const headChunk of maybeRenderHead()) {
+      head += chunkToString(result, headChunk);
+    }
   }
-  return renderResult;
+  try {
+    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 + head;
+          }
+        }
+        if (chunk instanceof Response)
+          return;
+        str += chunkToString(result, chunk);
+      }
+    };
+    const renderInstance = await renderComponent(result, displayName, Component, props, slots);
+    await renderInstance.render(destination);
+  } catch (e) {
+    if (AstroError.is(e) && !e.loc) {
+      e.setLocation({
+        file: route == null ? void 0 : route.component
+      });
+    }
+    throw e;
+  }
+  return str;
+}
+function nonAstroPageNeedsHeadInjection(pageComponent) {
+  return !!(pageComponent == null ? void 0 : pageComponent[needsHeadRenderingSymbol]);
 }
 export {
   renderComponent,
-  renderComponentToIterable
+  renderComponentToString
 };

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

@@ -1,3 +1,3 @@
 import type { SSRResult } from '../../../@types/astro';
 export declare function componentIsHTMLElement(Component: unknown): boolean;
-export declare function renderHTMLElement(result: SSRResult, constructor: typeof HTMLElement, props: any, slots: any): Promise<any>;
+export declare function renderHTMLElement(result: SSRResult, constructor: typeof HTMLElement, props: any, slots: any): Promise<string>;

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

@@ -1,7 +1,7 @@
 export type { AstroComponentFactory, AstroComponentInstance } from './astro/index';
-export { createHeadAndContent, renderAstroTemplateResult, renderTemplate, renderToString, } from './astro/index.js';
-export { Fragment, Renderer, stringifyChunk } from './common.js';
-export { renderComponent, renderComponentToIterable } from './component.js';
+export { createHeadAndContent, renderTemplate, renderToString } from './astro/index.js';
+export { Fragment, Renderer, chunkToByteArray, chunkToString } from './common.js';
+export { renderComponent, renderComponentToString } from './component.js';
 export { renderHTMLElement } from './dom.js';
 export { maybeRenderHead, renderHead } from './head.js';
 export { renderPage } from './page.js';

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

@@ -1,11 +1,6 @@
-import {
-  createHeadAndContent,
-  renderAstroTemplateResult,
-  renderTemplate,
-  renderToString
-} from "./astro/index.js";
-import { Fragment, Renderer, stringifyChunk } from "./common.js";
-import { renderComponent, renderComponentToIterable } from "./component.js";
+import { createHeadAndContent, renderTemplate, renderToString } from "./astro/index.js";
+import { Fragment, Renderer, chunkToByteArray, chunkToString } from "./common.js";
+import { renderComponent, renderComponentToString } from "./component.js";
 import { renderHTMLElement } from "./dom.js";
 import { maybeRenderHead, renderHead } from "./head.js";
 import { renderPage } from "./page.js";
@@ -16,12 +11,13 @@ export {
   Fragment,
   Renderer,
   addAttribute,
+  chunkToByteArray,
+  chunkToString,
   createHeadAndContent,
   defineScriptVars,
   maybeRenderHead,
-  renderAstroTemplateResult,
   renderComponent,
-  renderComponentToIterable,
+  renderComponentToString,
   renderHTMLElement,
   renderHead,
   renderPage,
@@ -31,6 +27,5 @@ export {
   renderTemplate,
   renderToString,
   renderUniqueStylesheet,
-  stringifyChunk,
   voidElementNames
 };

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

@@ -1,9 +1,4 @@
 import type { RouteData, SSRResult } from '../../../@types/astro';
+import { type NonAstroPageComponent } from './component.js';
 import type { AstroComponentFactory } from './index';
-declare const needsHeadRenderingSymbol: unique symbol;
-type NonAstroPageComponent = {
-    name: string;
-    [needsHeadRenderingSymbol]: boolean;
-};
-export declare function renderPage(result: SSRResult, componentFactory: AstroComponentFactory | NonAstroPageComponent, props: any, children: any, streaming: boolean, route?: RouteData | undefined): Promise<Response>;
-export {};
+export declare function renderPage(result: SSRResult, componentFactory: AstroComponentFactory | NonAstroPageComponent, props: any, children: any, streaming: boolean, route?: RouteData): Promise<Response>;

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

@@ -1,72 +1,23 @@
-import { AstroError } from "../../../core/errors/index.js";
-import { isHTMLString } from "../escape.js";
+import { renderComponentToString } from "./component.js";
 import { createResponse } from "../response.js";
-import { isAstroComponentFactory, isAstroComponentInstance } from "./astro/index.js";
+import { isAstroComponentFactory } 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");
-function nonAstroPageNeedsHeadInjection(pageComponent) {
-  return needsHeadRenderingSymbol in pageComponent && !!pageComponent[needsHeadRenderingSymbol];
-}
-async function iterableToHTMLBytes(result, iterable, onDocTypeInjection) {
-  const parts = new HTMLParts();
-  let i = 0;
-  for await (const chunk of iterable) {
-    if (isHTMLString(chunk)) {
-      if (i === 0) {
-        i++;
-        if (!/<!doctype html/i.test(String(chunk))) {
-          parts.append(`${result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n"}`, result);
-          if (onDocTypeInjection) {
-            await onDocTypeInjection(parts);
-          }
-        }
-      }
-    }
-    parts.append(chunk, result);
-  }
-  return parts.toArrayBuffer();
-}
+import { encoder } from "./common.js";
 async function renderPage(result, componentFactory, props, children, streaming, route) {
   var _a, _b;
   if (!isAstroComponentFactory(componentFactory)) {
     result._metadata.headInTree = ((_a = result.componentMetadata.get(componentFactory.moduleId)) == null ? void 0 : _a.containsHead) ?? false;
     const pageProps = { ...props ?? {}, "server:root": true };
-    let output;
-    let head = "";
-    try {
-      if (nonAstroPageNeedsHeadInjection(componentFactory)) {
-        const parts = new HTMLParts();
-        for await (const chunk of maybeRenderHead()) {
-          parts.append(chunk, result);
-        }
-        head = parts.toString();
-      }
-      const renderResult = await renderComponent(
-        result,
-        componentFactory.name,
-        componentFactory,
-        pageProps,
-        null
-      );
-      if (isAstroComponentInstance(renderResult)) {
-        output = renderResult.render();
-      } else {
-        output = renderResult;
-      }
-    } catch (e) {
-      if (AstroError.is(e) && !e.loc) {
-        e.setLocation({
-          file: route == null ? void 0 : route.component
-        });
-      }
-      throw e;
-    }
-    const bytes = await iterableToHTMLBytes(result, output, async (parts) => {
-      parts.append(head, result);
-    });
+    const str = await renderComponentToString(
+      result,
+      componentFactory.name,
+      componentFactory,
+      pageProps,
+      null,
+      true,
+      route
+    );
+    const bytes = encoder.encode(str);
     return new Response(bytes, {
       headers: new Headers([
         ["Content-Type", "text/html; charset=utf-8"],

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

@@ -2,6 +2,7 @@ import type { SSRResult } from '../../../@types/astro.js';
 import type { renderTemplate } from './astro/render-template.js';
 import type { RenderInstruction } from './types.js';
 import { HTMLString } from '../escape.js';
+import { type RenderInstance } from './common.js';
 type RenderTemplateResult = ReturnType<typeof renderTemplate>;
 export type ComponentSlots = Record<string, ComponentSlotValue>;
 export type ComponentSlotValue = (result: SSRResult) => RenderTemplateResult | Promise<RenderTemplateResult>;
@@ -12,7 +13,7 @@ export declare class SlotString extends HTMLString {
     constructor(content: string, instructions: null | RenderInstruction[]);
 }
 export declare function isSlotString(str: string): str is any;
-export declare function renderSlot(result: SSRResult, slotted: ComponentSlotValue | RenderTemplateResult, fallback?: ComponentSlotValue | RenderTemplateResult): AsyncGenerator<any, void, undefined>;
+export declare function renderSlot(result: SSRResult, slotted: ComponentSlotValue | RenderTemplateResult, fallback?: ComponentSlotValue | RenderTemplateResult): RenderInstance;
 export declare function renderSlotToString(result: SSRResult, slotted: ComponentSlotValue | RenderTemplateResult, fallback?: ComponentSlotValue | RenderTemplateResult): Promise<string>;
 interface RenderSlotsResult {
     slotInstructions: null | RenderInstruction[];

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

@@ -1,5 +1,6 @@
 import { HTMLString, markHTMLString } from "../escape.js";
 import { renderChild } from "./any.js";
+import { chunkToString } from "./common.js";
 const slotString = Symbol.for("astro:slot-string");
 class SlotString extends HTMLString {
   constructor(content, instructions) {
@@ -12,29 +13,35 @@ slotString;
 function isSlotString(str) {
   return !!str[slotString];
 }
-async function* renderSlot(result, slotted, fallback) {
-  if (slotted) {
-    let iterator = renderChild(typeof slotted === "function" ? slotted(result) : slotted);
-    yield* iterator;
-  }
-  if (fallback && !slotted) {
-    yield* renderSlot(result, fallback);
+function renderSlot(result, slotted, fallback) {
+  if (!slotted && fallback) {
+    return renderSlot(result, fallback);
   }
+  return {
+    async render(destination) {
+      await renderChild(destination, typeof slotted === "function" ? slotted(result) : slotted);
+    }
+  };
 }
 async function renderSlotToString(result, slotted, fallback) {
   let content = "";
   let instructions = null;
-  let iterator = renderSlot(result, slotted, fallback);
-  for await (const chunk of iterator) {
-    if (typeof chunk.type === "string") {
-      if (instructions === null) {
-        instructions = [];
+  const temporaryDestination = {
+    write(chunk) {
+      if (chunk instanceof Response)
+        return;
+      if (typeof chunk === "object" && "type" in chunk && typeof chunk.type === "string") {
+        if (instructions === null) {
+          instructions = [];
+        }
+        instructions.push(chunk);
+      } else {
+        content += chunkToString(result, chunk);
       }
-      instructions.push(chunk);
-    } else {
-      content += chunk;
     }
-  }
+  };
+  const renderInstance = renderSlot(result, slotted, fallback);
+  await renderInstance.render(temporaryDestination);
   return markHTMLString(new SlotString(content, instructions));
 }
 async function renderSlots(result, slots = {}) {

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

@@ -6,21 +6,3 @@ export declare function formatList(values: string[]): string;
 export declare function addAttribute(value: any, key: string, shouldEscape?: boolean): any;
 export declare function internalSpreadAttributes(values: Record<any, any>, shouldEscape?: boolean): any;
 export declare function renderElement(name: string, { props: _props, children }: SSRElement, shouldEscape?: boolean): string;
-/**
- * This will take an array of async iterables and start buffering them eagerly.
- * To avoid useless buffering, it will only start buffering the next tick, so the
- * first sync iterables won't be buffered.
- */
-export declare function bufferIterators<T>(iterators: AsyncIterable<T>[]): AsyncIterable<T>[];
-export declare class EagerAsyncIterableIterator {
-    #private;
-    constructor(iterable: AsyncIterable<any>);
-    /**
-     * Starts to eagerly fetch the inner iterator and cache the results.
-     * Note: This might not be called after next() has been called once, e.g. the iterator is started
-     */
-    buffer(): Promise<void>;
-    next(): Promise<IteratorResult<any, any>>;
-    isStarted(): boolean;
-    [Symbol.asyncIterator](): this;
-}

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

@@ -103,109 +103,8 @@ function renderElement(name, { props: _props, children = "" }, shouldEscape = tr
   }
   return `<${name}${internalSpreadAttributes(props, shouldEscape)}>${children}</${name}>`;
 }
-const iteratorQueue = [];
-function queueIteratorBuffers(iterators) {
-  if (iteratorQueue.length === 0) {
-    setTimeout(() => {
-      iteratorQueue.forEach((its) => its.forEach((it) => !it.isStarted() && it.buffer()));
-      iteratorQueue.length = 0;
-    });
-  }
-  iteratorQueue.push(iterators);
-}
-function bufferIterators(iterators) {
-  const eagerIterators = iterators.map((it) => new EagerAsyncIterableIterator(it));
-  queueIteratorBuffers(eagerIterators);
-  return eagerIterators;
-}
-class EagerAsyncIterableIterator {
-  #iterable;
-  #queue = new Queue();
-  #error = void 0;
-  #next;
-  /**
-   * Whether the proxy is running in buffering or pass-through mode
-   */
-  #isBuffering = false;
-  #gen = void 0;
-  #isStarted = false;
-  constructor(iterable) {
-    this.#iterable = iterable;
-  }
-  /**
-   * Starts to eagerly fetch the inner iterator and cache the results.
-   * Note: This might not be called after next() has been called once, e.g. the iterator is started
-   */
-  async buffer() {
-    if (this.#gen) {
-      throw new Error("Cannot not switch from non-buffer to buffer mode");
-    }
-    this.#isBuffering = true;
-    this.#isStarted = true;
-    this.#gen = this.#iterable[Symbol.asyncIterator]();
-    let value = void 0;
-    do {
-      this.#next = this.#gen.next();
-      try {
-        value = await this.#next;
-        this.#queue.push(value);
-      } catch (e) {
-        this.#error = e;
-      }
-    } while (value && !value.done);
-  }
-  async next() {
-    if (this.#error) {
-      throw this.#error;
-    }
-    if (!this.#isBuffering) {
-      if (!this.#gen) {
-        this.#isStarted = true;
-        this.#gen = this.#iterable[Symbol.asyncIterator]();
-      }
-      return await this.#gen.next();
-    }
-    if (!this.#queue.isEmpty()) {
-      return this.#queue.shift();
-    }
-    await this.#next;
-    return this.#queue.shift();
-  }
-  isStarted() {
-    return this.#isStarted;
-  }
-  [Symbol.asyncIterator]() {
-    return this;
-  }
-}
-class Queue {
-  constructor() {
-    this.head = void 0;
-    this.tail = void 0;
-  }
-  push(item) {
-    if (this.head === void 0) {
-      this.head = { item };
-      this.tail = this.head;
-    } else {
-      this.tail.next = { item };
-      this.tail = this.tail.next;
-    }
-  }
-  isEmpty() {
-    return this.head === void 0;
-  }
-  shift() {
-    var _a, _b;
-    const val = (_a = this.head) == null ? void 0 : _a.item;
-    this.head = (_b = this.head) == null ? void 0 : _b.next;
-    return val;
-  }
-}
 export {
-  EagerAsyncIterableIterator,
   addAttribute,
-  bufferIterators,
   defineScriptVars,
   formatList,
   internalSpreadAttributes,

package/package.json

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