astro 1.6.13 → 1.6.15

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

@@ -0,0 +1,31 @@
+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.propagation.has(factory.moduleId) && hint === "none") {
+    hint = result.propagation.get(factory.moduleId);
+  }
+  return hint === "in-tree" || hint === "self";
+}
+export {
+  isAPropagatingComponent,
+  isAstroComponentFactory,
+  renderToString
+};

package/dist/runtime/server/render/astro/head-and-content.d.ts

@@ -0,0 +1,10 @@
+import type { RenderTemplateResult } from './render-template';
+declare const headAndContentSym: unique symbol;
+export declare type HeadAndContent = {
+    [headAndContentSym]: true;
+    head: string | RenderTemplateResult;
+    content: RenderTemplateResult;
+};
+export declare function isHeadAndContent(obj: unknown): obj is HeadAndContent;
+export declare function createHeadAndContent(head: string | RenderTemplateResult, content: RenderTemplateResult): HeadAndContent;
+export {};

package/dist/runtime/server/render/astro/head-and-content.js

@@ -0,0 +1,15 @@
+const headAndContentSym = Symbol.for("astro.headAndContent");
+function isHeadAndContent(obj) {
+  return typeof obj === "object" && !!obj[headAndContentSym];
+}
+function createHeadAndContent(head, content) {
+  return {
+    [headAndContentSym]: true,
+    head,
+    content
+  };
+}
+export {
+  createHeadAndContent,
+  isHeadAndContent
+};

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

@@ -0,0 +1,6 @@
+export type { AstroComponentFactory } from './factory';
+export { isAstroComponentFactory, renderToString } 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';

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

@@ -0,0 +1,19 @@
+import { isAstroComponentFactory, renderToString } 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";
+export {
+  createAstroComponentInstance,
+  createHeadAndContent,
+  isAstroComponentFactory,
+  isAstroComponentInstance,
+  isHeadAndContent,
+  isRenderTemplateResult,
+  renderAstroTemplateResult,
+  renderTemplate,
+  renderToString
+};

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

@@ -0,0 +1,18 @@
+import type { SSRResult } from '../../../../@types/astro';
+import type { AstroComponentFactory, AstroFactoryReturnValue } from './factory.js';
+declare type ComponentProps = Record<string | number, any>;
+declare const astroComponentInstanceSym: unique symbol;
+export declare class AstroComponentInstance {
+    [astroComponentInstanceSym]: boolean;
+    private readonly result;
+    private readonly props;
+    private readonly slots;
+    private readonly factory;
+    private returnValue;
+    constructor(result: SSRResult, props: ComponentProps, slots: any, factory: AstroComponentFactory);
+    init(): Promise<AstroFactoryReturnValue>;
+    render(): AsyncGenerator<any, void, undefined>;
+}
+export declare function createAstroComponentInstance(result: SSRResult, displayName: string, factory: AstroComponentFactory, props: ComponentProps, slots?: any): AstroComponentInstance;
+export declare function isAstroComponentInstance(obj: unknown): obj is AstroComponentInstance;
+export {};

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

@@ -0,0 +1,62 @@
+var _a;
+import { HydrationDirectiveProps } from "../../hydration.js";
+import { isPromise } from "../../util.js";
+import { renderChild } from "../any.js";
+import { isAPropagatingComponent } from "./factory.js";
+import { isHeadAndContent } from "./head-and-content.js";
+const astroComponentInstanceSym = Symbol.for("astro.componentInstance");
+class AstroComponentInstance {
+  constructor(result, props, slots, factory) {
+    this[_a] = true;
+    this.result = result;
+    this.props = props;
+    this.slots = slots;
+    this.factory = factory;
+  }
+  async init() {
+    this.returnValue = this.factory(this.result, this.props, this.slots);
+    return this.returnValue;
+  }
+  async *render() {
+    if (this.returnValue === void 0) {
+      await this.init();
+    }
+    let value = this.returnValue;
+    if (isPromise(value)) {
+      value = await value;
+    }
+    if (isHeadAndContent(value)) {
+      yield* value.content;
+    } else {
+      yield* renderChild(value);
+    }
+  }
+}
+_a = astroComponentInstanceSym;
+function validateComponentProps(props, displayName) {
+  if (props != null) {
+    for (const prop of Object.keys(props)) {
+      if (HydrationDirectiveProps.has(prop)) {
+        console.warn(
+          `You are attempting to render <${displayName} ${prop} />, but ${displayName} 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.`
+        );
+      }
+    }
+  }
+}
+function createAstroComponentInstance(result, displayName, factory, props, slots = {}) {
+  validateComponentProps(props, displayName);
+  const instance = new AstroComponentInstance(result, props, slots, factory);
+  if (isAPropagatingComponent(result, factory) && !result.propagators.has(factory)) {
+    result.propagators.set(factory, instance);
+  }
+  return instance;
+}
+function isAstroComponentInstance(obj) {
+  return typeof obj === "object" && !!obj[astroComponentInstanceSym];
+}
+export {
+  AstroComponentInstance,
+  createAstroComponentInstance,
+  isAstroComponentInstance
+};

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

@@ -0,0 +1,16 @@
+import type { RenderInstruction } from '../types';
+import { HTMLBytes } from '../../escape.js';
+declare const renderTemplateResultSym: unique symbol;
+export declare class RenderTemplateResult {
+    [renderTemplateResultSym]: boolean;
+    private htmlParts;
+    private expressions;
+    private error;
+    constructor(htmlParts: TemplateStringsArray, expressions: unknown[]);
+    get [Symbol.toStringTag](): string;
+    [Symbol.asyncIterator](): AsyncGenerator<any, void, undefined>;
+}
+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

@@ -0,0 +1,65 @@
+var _a;
+import { markHTMLString } from "../../escape.js";
+import { isPromise } from "../../util.js";
+import { renderChild } from "../any.js";
+const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult");
+class RenderTemplateResult {
+  constructor(htmlParts, expressions) {
+    this[_a] = true;
+    this.htmlParts = htmlParts;
+    this.error = void 0;
+    this.expressions = expressions.map((expression) => {
+      if (isPromise(expression)) {
+        return Promise.resolve(expression).catch((err) => {
+          if (!this.error) {
+            this.error = err;
+            throw err;
+          }
+        });
+      }
+      return expression;
+    });
+  }
+  get [(_a = renderTemplateResultSym, Symbol.toStringTag)]() {
+    return "AstroComponent";
+  }
+  async *[Symbol.asyncIterator]() {
+    const { htmlParts, expressions } = this;
+    for (let i = 0; i < htmlParts.length; i++) {
+      const html = htmlParts[i];
+      const expression = expressions[i];
+      yield markHTMLString(html);
+      yield* renderChild(expression);
+    }
+  }
+}
+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/component.d.ts

@@ -1,5 +1,7 @@
-import type { RouteData, SSRResult } from '../../../@types/astro';
+import type { SSRResult } from '../../../@types/astro';
 import type { RenderInstruction } from './types.js';
 import { HTMLBytes } from '../escape.js';
+import { type AstroComponentInstance } from './astro/index.js';
 export declare type ComponentIterable = AsyncIterable<string | HTMLBytes | RenderInstruction>;
-export declare function renderComponent(result: SSRResult, displayName: string, Component: unknown, _props: Record<string | number, any>, slots?: any, route?: RouteData | undefined): Promise<ComponentIterable>;
+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;

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

@@ -3,12 +3,14 @@ import { markHTMLString } from "../escape.js";
 import { extractDirectives, generateHydrateScript } from "../hydration.js";
 import { serializeProps } from "../serialize.js";
 import { shorthash } from "../shorthash.js";
+import { isPromise } from "../util.js";
 import {
+  createAstroComponentInstance,
   isAstroComponentFactory,
-  renderAstroComponent,
-  renderTemplate,
-  renderToIterable
-} from "./astro.js";
+  isAstroComponentInstance,
+  renderAstroTemplateResult,
+  renderTemplate
+} from "./astro/index.js";
 import { Fragment, Renderer, stringifyChunk } from "./common.js";
 import { componentIsHTMLElement, renderHTMLElement } from "./dom.js";
 import { renderSlot, renderSlots } from "./slot.js";
@@ -34,43 +36,14 @@ function guessRenderers(componentUrl) {
       ];
   }
 }
-function getComponentType(Component) {
-  if (Component === Fragment) {
-    return "fragment";
-  }
-  if (Component && typeof Component === "object" && Component["astro:html"]) {
-    return "html";
-  }
-  if (isAstroComponentFactory(Component)) {
-    return "astro-factory";
-  }
-  return "unknown";
+function isFragmentComponent(Component) {
+  return Component === Fragment;
+}
+function isHTMLComponent(Component) {
+  return Component && typeof Component === "object" && Component["astro:html"];
 }
-async function renderComponent(result, displayName, Component, _props, slots = {}, route) {
+async function renderFrameworkComponent(result, displayName, Component, _props, slots = {}) {
   var _a, _b;
-  Component = await Component ?? Component;
-  switch (getComponentType(Component)) {
-    case "fragment": {
-      const children2 = await renderSlot(result, slots == null ? void 0 : slots.default);
-      if (children2 == null) {
-        return children2;
-      }
-      return markHTMLString(children2);
-    }
-    case "html": {
-      const { slotInstructions: slotInstructions2, children: children2 } = await renderSlots(result, slots);
-      const html2 = Component.render({ slots: children2 });
-      const hydrationHtml = slotInstructions2 ? slotInstructions2.map((instr) => stringifyChunk(result, instr)).join("") : "";
-      return markHTMLString(hydrationHtml + html2);
-    }
-    case "astro-factory": {
-      async function* renderAstroComponentInline() {
-        let iterable = await renderToIterable(result, Component, displayName, _props, slots);
-        yield* iterable;
-      }
-      return renderAstroComponentInline();
-    }
-  }
   if (!Component && !_props["client:only"]) {
     throw new Error(
       `Unable to render ${displayName} because it is ${Component}!
@@ -215,7 +188,7 @@ If you're still stuck, please open an issue on GitHub or join us at https://astr
   }
   if (!html && typeof Component === "string") {
     const childSlots = Object.values(children).join("");
-    const iterable = renderAstroComponent(
+    const iterable = renderAstroTemplateResult(
       await renderTemplate`<${Component}${internalSpreadAttributes(props)}${markHTMLString(
         childSlots === "" && voidElementNames.test(Component) ? `/>` : `>${childSlots}</${Component}>`
       )}`
@@ -277,6 +250,44 @@ ${serializeProps(
   }
   return renderAll();
 }
+async function renderFragmentComponent(result, slots = {}) {
+  const children = await renderSlot(result, slots == null ? void 0 : slots.default);
+  if (children == null) {
+    return children;
+  }
+  return markHTMLString(children);
+}
+async function renderHTMLComponent(result, Component, _props, slots = {}) {
+  const { slotInstructions, children } = await renderSlots(result, slots);
+  const html = Component.render({ slots: children });
+  const hydrationHtml = slotInstructions ? slotInstructions.map((instr) => stringifyChunk(result, instr)).join("") : "";
+  return markHTMLString(hydrationHtml + html);
+}
+function renderComponent(result, displayName, Component, props, slots = {}) {
+  if (isPromise(Component)) {
+    return Promise.resolve(Component).then((Unwrapped) => {
+      return renderComponent(result, displayName, Unwrapped, props, slots);
+    });
+  }
+  if (isFragmentComponent(Component)) {
+    return renderFragmentComponent(result, slots);
+  }
+  if (isHTMLComponent(Component)) {
+    return renderHTMLComponent(result, Component, props, slots);
+  }
+  if (isAstroComponentFactory(Component)) {
+    return createAstroComponentInstance(result, displayName, Component, props, slots);
+  }
+  return 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();
+  }
+  return renderResult;
+}
 export {
-  renderComponent
+  renderComponent,
+  renderComponentToIterable
 };

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

@@ -1,3 +1,4 @@
 import type { SSRResult } from '../../../@types/astro';
-export declare function renderHead(result: SSRResult): Promise<string>;
-export declare function maybeRenderHead(result: SSRResult): AsyncIterable<string>;
+export declare function createRenderHead(result: SSRResult): () => any;
+export declare const renderHead: typeof createRenderHead;
+export declare function maybeRenderHead(result: SSRResult): AsyncGenerator<any, void, unknown>;

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

@@ -1,27 +1,44 @@
 import { markHTMLString } from "../escape.js";
+import { renderChild } from "./any.js";
 import { renderElement } from "./util.js";
 const uniqueElements = (item, index, all) => {
   const props = JSON.stringify(item.props);
   const children = item.children;
   return index === all.findIndex((i) => JSON.stringify(i.props) === props && i.children == children);
 };
-function renderHead(result) {
-  result._metadata.hasRenderedHead = true;
+async function* renderExtraHead(result, base) {
+  yield base;
+  for (const part of result.extraHead) {
+    yield* renderChild(part);
+  }
+}
+function renderAllHeadContent(result) {
   const styles = Array.from(result.styles).filter(uniqueElements).map((style) => renderElement("style", style));
   result.styles.clear();
   const scripts = Array.from(result.scripts).filter(uniqueElements).map((script, i) => {
     return renderElement("script", script, false);
   });
   const links = Array.from(result.links).filter(uniqueElements).map((link) => renderElement("link", link, false));
-  return markHTMLString(links.join("\n") + styles.join("\n") + scripts.join("\n"));
+  const baseHeadContent = markHTMLString(links.join("\n") + styles.join("\n") + scripts.join("\n"));
+  if (result.extraHead.length > 0) {
+    return renderExtraHead(result, baseHeadContent);
+  } else {
+    return baseHeadContent;
+  }
+}
+function createRenderHead(result) {
+  result._metadata.hasRenderedHead = true;
+  return renderAllHeadContent.bind(null, result);
 }
+const renderHead = createRenderHead;
 async function* maybeRenderHead(result) {
   if (result._metadata.hasRenderedHead) {
     return;
   }
-  yield renderHead(result);
+  yield createRenderHead(result)();
 }
 export {
+  createRenderHead,
   maybeRenderHead,
   renderHead
 };

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

@@ -1,14 +1,11 @@
-import { renderTemplate } from './astro.js';
-export { renderAstroComponent, renderTemplate, renderToString } from './astro.js';
+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 } from './component.js';
+export { renderComponent, renderComponentToIterable } from './component.js';
 export { renderHTMLElement } from './dom.js';
 export { maybeRenderHead, renderHead } from './head.js';
 export { renderPage } from './page.js';
 export { renderSlot } from './slot.js';
+export { renderUniqueStylesheet } from './stylesheet.js';
 export type { RenderInstruction } from './types';
 export { addAttribute, defineScriptVars, voidElementNames } from './util.js';
-export interface AstroComponentFactory {
-    (result: any, props: any, slots: any): ReturnType<typeof renderTemplate> | Response;
-    isAstroComponentFactory?: boolean;
-}

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

@@ -1,25 +1,34 @@
-import { renderAstroComponent, renderTemplate as renderTemplate2, renderToString } from "./astro.js";
+import {
+  createHeadAndContent,
+  renderAstroTemplateResult,
+  renderTemplate,
+  renderToString
+} from "./astro/index.js";
 import { Fragment, Renderer, stringifyChunk } from "./common.js";
-import { renderComponent } from "./component.js";
+import { renderComponent, renderComponentToIterable } from "./component.js";
 import { renderHTMLElement } from "./dom.js";
 import { maybeRenderHead, renderHead } from "./head.js";
 import { renderPage } from "./page.js";
 import { renderSlot } from "./slot.js";
+import { renderUniqueStylesheet } from "./stylesheet.js";
 import { addAttribute, defineScriptVars, voidElementNames } from "./util.js";
 export {
   Fragment,
   Renderer,
   addAttribute,
+  createHeadAndContent,
   defineScriptVars,
   maybeRenderHead,
-  renderAstroComponent,
+  renderAstroTemplateResult,
   renderComponent,
+  renderComponentToIterable,
   renderHTMLElement,
   renderHead,
   renderPage,
   renderSlot,
-  renderTemplate2 as renderTemplate,
+  renderTemplate,
   renderToString,
+  renderUniqueStylesheet,
   stringifyChunk,
   voidElementNames
 };

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

@@ -1,7 +1,13 @@
 import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
 import { isHTMLString } from "../escape.js";
 import { createResponse } from "../response.js";
-import { isAstroComponent, isAstroComponentFactory, renderAstroComponent } from "./astro.js";
+import {
+  isAstroComponentFactory,
+  isAstroComponentInstance,
+  isHeadAndContent,
+  isRenderTemplateResult,
+  renderAstroTemplateResult
+} from "./astro/index.js";
 import { chunkToByteArray, encoder, HTMLParts } from "./common.js";
 import { renderComponent } from "./component.js";
 import { maybeRenderHead } from "./head.js";
@@ -28,19 +34,36 @@ async function iterableToHTMLBytes(result, iterable, onDocTypeInjection) {
   }
   return parts.toArrayBuffer();
 }
+async function bufferHeadContent(result) {
+  const iterator = result.propagators.values();
+  while (true) {
+    const { value, done } = iterator.next();
+    if (done) {
+      break;
+    }
+    const returnValue = await value.init();
+    if (isHeadAndContent(returnValue)) {
+      result.extraHead.push(returnValue.head);
+    }
+  }
+}
 async function renderPage(result, componentFactory, props, children, streaming, route) {
   if (!isAstroComponentFactory(componentFactory)) {
     const pageProps = { ...props ?? {}, "server:root": true };
     let output;
     try {
-      output = await renderComponent(
+      const renderResult = await renderComponent(
         result,
         componentFactory.name,
         componentFactory,
         pageProps,
-        null,
-        route
+        null
       );
+      if (isAstroComponentInstance(renderResult)) {
+        output = renderResult.render();
+      } else {
+        output = renderResult;
+      }
     } catch (e) {
       if (AstroError.is(e) && !e.loc) {
         e.setLocation({
@@ -64,8 +87,11 @@ async function renderPage(result, componentFactory, props, children, streaming,
     });
   }
   const factoryReturnValue = await componentFactory(result, props, children);
-  if (isAstroComponent(factoryReturnValue)) {
-    let iterable = renderAstroComponent(factoryReturnValue);
+  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;

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

@@ -0,0 +1,7 @@
+import { SSRResult } from '../../../@types/astro';
+export declare function renderStylesheet({ href }: {
+    href: string;
+}): any;
+export declare function renderUniqueStylesheet(result: SSRResult, link: {
+    href: string;
+}): any;

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

@@ -0,0 +1,30 @@
+import { markHTMLString } from "../escape.js";
+import { renderElement } from "./util.js";
+const stylesheetRel = "stylesheet";
+function renderStylesheet({ href }) {
+  return markHTMLString(
+    renderElement(
+      "link",
+      {
+        props: {
+          rel: stylesheetRel,
+          href
+        },
+        children: ""
+      },
+      false
+    )
+  );
+}
+function renderUniqueStylesheet(result, link) {
+  for (const existingLink of result.links) {
+    if (existingLink.props.rel === stylesheetRel && existingLink.props.href === link.href) {
+      return "";
+    }
+  }
+  return renderStylesheet(link);
+}
+export {
+  renderStylesheet,
+  renderUniqueStylesheet
+};

package/dist/vite-plugin-astro/index.d.ts

@@ -1,10 +1,12 @@
 import type * as vite from 'vite';
 import type { AstroSettings } from '../@types/astro';
 import type { LogOptions } from '../core/logger/core.js';
+import type { PluginMetadata as AstroPluginMetadata } from './types';
+export { getAstroMetadata } from './metadata.js';
+export type { AstroPluginMetadata };
 interface AstroPluginOptions {
     settings: AstroSettings;
     logging: LogOptions;
 }
 /** Transform .astro files for Vite */
 export default function astro({ settings, logging }: AstroPluginOptions): vite.Plugin;
-export {};