astro 2.3.4 → 2.4.0

package/dist/core/middleware/callMiddleware.js

@@ -0,0 +1,38 @@
+import { AstroError, AstroErrorData } from "../errors/index.js";
+async function callMiddleware(onRequest, apiContext, responseFunction) {
+  let resolveResolve;
+  new Promise((resolve) => {
+    resolveResolve = resolve;
+  });
+  let nextCalled = false;
+  const next = async () => {
+    nextCalled = true;
+    return await responseFunction();
+  };
+  let middlewarePromise = onRequest(apiContext, next);
+  return await Promise.resolve(middlewarePromise).then(async (value) => {
+    if (nextCalled) {
+      if (typeof value !== "undefined") {
+        if (value instanceof Response === false) {
+          throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
+        }
+        return value;
+      } else {
+        const responseResult = await responseFunction();
+        return responseResult;
+      }
+    } else if (typeof value === "undefined") {
+      throw new AstroError(AstroErrorData.MiddlewareNoDataOrNextCalled);
+    } else if (value instanceof Response === false) {
+      throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
+    } else {
+      return value;
+    }
+  });
+}
+function isEndpointResult(response) {
+  return response && typeof response.body !== "undefined";
+}
+export {
+  callMiddleware
+};

package/dist/core/middleware/index.d.ts

@@ -0,0 +1,4 @@
+import type { MiddlewareResponseHandler } from '../../@types/astro';
+import { sequence } from './sequence.js';
+declare function defineMiddleware(fn: MiddlewareResponseHandler): MiddlewareResponseHandler;
+export { sequence, defineMiddleware };

package/dist/core/middleware/index.js

@@ -0,0 +1,8 @@
+import { sequence } from "./sequence.js";
+function defineMiddleware(fn) {
+  return fn;
+}
+export {
+  defineMiddleware,
+  sequence
+};

package/dist/core/middleware/loadMiddleware.d.ts

@@ -0,0 +1,8 @@
+import type { AstroSettings } from '../../@types/astro';
+import type { ModuleLoader } from '../module-loader';
+/**
+ * It accepts a module loader and the astro settings, and it attempts to load the middlewares defined in the configuration.
+ *
+ * If not middlewares were not set, the function returns an empty array.
+ */
+export declare function loadMiddleware(moduleLoader: ModuleLoader, srcDir: AstroSettings['config']['srcDir']): Promise<Record<string, any> | undefined>;

package/dist/core/middleware/loadMiddleware.js

@@ -0,0 +1,13 @@
+import { MIDDLEWARE_PATH_SEGMENT_NAME } from "../constants.js";
+async function loadMiddleware(moduleLoader, srcDir) {
+  let middlewarePath = srcDir.pathname + "/" + MIDDLEWARE_PATH_SEGMENT_NAME;
+  try {
+    const module = await moduleLoader.import(middlewarePath);
+    return module;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  loadMiddleware
+};

package/dist/core/middleware/sequence.d.ts

@@ -0,0 +1,6 @@
+import type { MiddlewareResponseHandler } from '../../@types/astro';
+/**
+ *
+ * It accepts one or more middleware handlers and makes sure that they are run in sequence.
+ */
+export declare function sequence(...handlers: MiddlewareResponseHandler[]): MiddlewareResponseHandler;

package/dist/core/middleware/sequence.js

@@ -0,0 +1,27 @@
+import { defineMiddleware } from "./index.js";
+function sequence(...handlers) {
+  const length = handlers.length;
+  if (!length) {
+    const handler = defineMiddleware((context, next) => {
+      return next();
+    });
+    return handler;
+  }
+  return defineMiddleware((context, next) => {
+    return applyHandle(0, context);
+    function applyHandle(i, handleContext) {
+      const handle = handlers[i];
+      const result = handle(handleContext, async () => {
+        if (i < length - 1) {
+          return applyHandle(i + 1, handleContext);
+        } else {
+          return next();
+        }
+      });
+      return result;
+    }
+  });
+}
+export {
+  sequence
+};

package/dist/core/render/context.d.ts

@@ -1,4 +1,5 @@
-import type { RouteData, SSRElement, SSRResult } from '../../@types/astro';
+import type { ComponentInstance, Params, Props, RouteData, SSRElement, SSRResult } from '../../@types/astro';
+import type { Environment } from './environment';
 /**
  * The RenderContext represents the parts of rendering that are specific to one request.
  */
@@ -13,9 +14,13 @@ export interface RenderContext {
     componentMetadata?: SSRResult['componentMetadata'];
     route?: RouteData;
     status?: number;
+    params: Params;
+    props: Props;
 }
 export type CreateRenderContextArgs = Partial<RenderContext> & {
     origin?: string;
     request: RenderContext['request'];
+    mod: ComponentInstance;
+    env: Environment;
 };
-export declare function createRenderContext(options: CreateRenderContextArgs): RenderContext;
+export declare function createRenderContext(options: CreateRenderContextArgs): Promise<RenderContext>;

package/dist/core/render/context.js

@@ -1,13 +1,24 @@
-function createRenderContext(options) {
+import { getParamsAndPropsOrThrow } from "./core.js";
+async function createRenderContext(options) {
   const request = options.request;
   const url = new URL(request.url);
   const origin = options.origin ?? url.origin;
   const pathname = options.pathname ?? url.pathname;
+  const [params, props] = await getParamsAndPropsOrThrow({
+    mod: options.mod,
+    route: options.route,
+    routeCache: options.env.routeCache,
+    pathname,
+    logging: options.env.logging,
+    ssr: options.env.ssr
+  });
   return {
     ...options,
     origin,
     pathname,
-    url
+    url,
+    params,
+    props
   };
 }
 export {

package/dist/core/render/core.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentInstance, Params, Props, RouteData } from '../../@types/astro';
+import type { APIContext, ComponentInstance, Params, Props, RouteData } from '../../@types/astro';
 import type { LogOptions } from '../logger/core.js';
 import type { RenderContext } from './context.js';
 import type { Environment } from './environment.js';
@@ -14,6 +14,26 @@ interface GetParamsAndPropsOptions {
 export declare const enum GetParamsAndPropsError {
     NoMatchingStaticPath = 0
 }
+/**
+ * It retrieves `Params` and `Props`, or throws an error
+ * if they are not correctly retrieved.
+ */
+export declare function getParamsAndPropsOrThrow(options: GetParamsAndPropsOptions): Promise<[Params, Props]>;
 export declare function getParamsAndProps(opts: GetParamsAndPropsOptions): Promise<[Params, Props] | GetParamsAndPropsError>;
-export declare function renderPage(mod: ComponentInstance, ctx: RenderContext, env: Environment): Promise<Response>;
+export type RenderPage = {
+    mod: ComponentInstance;
+    renderContext: RenderContext;
+    env: Environment;
+    apiContext?: APIContext;
+};
+export declare function renderPage({ mod, renderContext, env, apiContext }: RenderPage): Promise<Response>;
+/**
+ * Checks whether any value can is serializable.
+ *
+ * A serializable value contains plain values. For example, `Proxy`, `Set`, `Map`, functions, etc.
+ * are not serializable objects.
+ *
+ * @param object
+ */
+export declare function isValueSerializable(value: unknown): boolean;
 export {};

package/dist/core/render/core.js

@@ -8,6 +8,18 @@ var GetParamsAndPropsError = /* @__PURE__ */ ((GetParamsAndPropsError2) => {
   GetParamsAndPropsError2[GetParamsAndPropsError2["NoMatchingStaticPath"] = 0] = "NoMatchingStaticPath";
   return GetParamsAndPropsError2;
 })(GetParamsAndPropsError || {});
+async function getParamsAndPropsOrThrow(options) {
+  var _a, _b;
+  let paramsAndPropsResp = await getParamsAndProps(options);
+  if (paramsAndPropsResp === 0 /* NoMatchingStaticPath */) {
+    throw new AstroError({
+      ...AstroErrorData.NoMatchingStaticPathFound,
+      message: AstroErrorData.NoMatchingStaticPathFound.message(options.pathname),
+      hint: ((_a = options.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = options.route) == null ? void 0 : _b.component]) : ""
+    });
+  }
+  return paramsAndPropsResp;
+}
 async function getParamsAndProps(opts) {
   const { logging, mod, route, routeCache, pathname, ssr } = opts;
   let params = {};
@@ -49,65 +61,89 @@ async function getParamsAndProps(opts) {
   }
   return [params, pageProps];
 }
-async function renderPage(mod, ctx, env) {
-  var _a, _b;
-  const paramsAndPropsRes = await getParamsAndProps({
-    logging: env.logging,
-    mod,
-    route: ctx.route,
-    routeCache: env.routeCache,
-    pathname: ctx.pathname,
-    ssr: env.ssr
-  });
-  if (paramsAndPropsRes === 0 /* NoMatchingStaticPath */) {
-    throw new AstroError({
-      ...AstroErrorData.NoMatchingStaticPathFound,
-      message: AstroErrorData.NoMatchingStaticPathFound.message(ctx.pathname),
-      hint: ((_a = ctx.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = ctx.route) == null ? void 0 : _b.component]) : ""
-    });
-  }
-  const [params, pageProps] = paramsAndPropsRes;
+async function renderPage({ mod, renderContext, env, apiContext }) {
   const Component = mod.default;
   if (!Component)
     throw new Error(`Expected an exported Astro component but received typeof ${typeof Component}`);
+  let locals = {};
+  if (apiContext) {
+    if (env.mode === "development" && !isValueSerializable(apiContext.locals)) {
+      throw new AstroError({
+        ...AstroErrorData.LocalsNotSerializable,
+        message: AstroErrorData.LocalsNotSerializable.message(renderContext.pathname)
+      });
+    }
+    locals = apiContext.locals;
+  }
   const result = createResult({
     adapterName: env.adapterName,
-    links: ctx.links,
-    styles: ctx.styles,
+    links: renderContext.links,
+    styles: renderContext.styles,
     logging: env.logging,
     markdown: env.markdown,
     mode: env.mode,
-    origin: ctx.origin,
-    params,
-    props: pageProps,
-    pathname: ctx.pathname,
-    componentMetadata: ctx.componentMetadata,
+    origin: renderContext.origin,
+    params: renderContext.params,
+    props: renderContext.props,
+    pathname: renderContext.pathname,
+    componentMetadata: renderContext.componentMetadata,
     resolve: env.resolve,
     renderers: env.renderers,
-    request: ctx.request,
+    request: renderContext.request,
     site: env.site,
-    scripts: ctx.scripts,
+    scripts: renderContext.scripts,
     ssr: env.ssr,
-    status: ctx.status ?? 200
+    status: renderContext.status ?? 200,
+    locals
   });
   if (typeof mod.components === "object") {
-    Object.assign(pageProps, { components: mod.components });
+    Object.assign(renderContext.props, { components: mod.components });
   }
-  const response = await runtimeRenderPage(
+  let response = await runtimeRenderPage(
     result,
     Component,
-    pageProps,
+    renderContext.props,
     null,
     env.streaming,
-    ctx.route
+    renderContext.route
   );
   if (result.cookies) {
     attachToResponse(response, result.cookies);
   }
   return response;
 }
+function isValueSerializable(value) {
+  let type = typeof value;
+  let plainObject = true;
+  if (type === "object" && isPlainObject(value)) {
+    for (const [, nestedValue] of Object.entries(value)) {
+      if (!isValueSerializable(nestedValue)) {
+        plainObject = false;
+        break;
+      }
+    }
+  } else {
+    plainObject = false;
+  }
+  let result = value === null || type === "string" || type === "number" || type === "boolean" || Array.isArray(value) || plainObject;
+  return result;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = Object.getPrototypeOf(value);
+  if (proto === null)
+    return true;
+  let baseProto = proto;
+  while (Object.getPrototypeOf(baseProto) !== null) {
+    baseProto = Object.getPrototypeOf(baseProto);
+  }
+  return proto === baseProto;
+}
 export {
   GetParamsAndPropsError,
   getParamsAndProps,
+  getParamsAndPropsOrThrow,
+  isValueSerializable,
   renderPage
 };

package/dist/core/render/dev/index.d.ts

@@ -1,4 +1,4 @@
-import type { AstroSettings, ComponentInstance, RouteData, SSRLoadedRenderer } from '../../../@types/astro';
+import type { AstroMiddlewareInstance, AstroSettings, ComponentInstance, RouteData, SSRLoadedRenderer } from '../../../@types/astro';
 import type { ModuleLoader } from '../../module-loader/index';
 import type { DevelopmentEnvironment } from './environment';
 export { createDevelopmentEnvironment } from './environment.js';
@@ -18,6 +18,10 @@ export interface SSROptions {
     request: Request;
     /** optional, in case we need to render something outside of a dev server */
     route?: RouteData;
+    /**
+     * Optional middlewares
+     */
+    middleware?: AstroMiddlewareInstance<unknown>;
 }
 export type ComponentPreload = [SSRLoadedRenderer[], ComponentInstance];
 export declare function loadRenderers(moduleLoader: ModuleLoader, settings: AstroSettings): Promise<SSRLoadedRenderer[]>;

package/dist/core/render/dev/index.js

@@ -1,7 +1,9 @@
 import { fileURLToPath } from "url";
 import { PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
+import { createAPIContext } from "../../endpoint/index.js";
 import { enhanceViteSSRError } from "../../errors/dev/index.js";
 import { AggregateError, CSSError, MarkdownError } from "../../errors/index.js";
+import { callMiddleware } from "../../middleware/callMiddleware.js";
 import { isPage, resolveIdToUrl, viteID } from "../../util.js";
 import { createRenderContext, renderPage as coreRenderPage } from "../index.js";
 import { filterFoundRenderers, loadRenderer } from "../renderer.js";
@@ -96,7 +98,8 @@ async function renderPage(options) {
     env: options.env,
     filePath: options.filePath
   });
-  const ctx = createRenderContext({
+  const { env } = options;
+  const renderContext = await createRenderContext({
     request: options.request,
     origin: options.origin,
     pathname: options.pathname,
@@ -104,9 +107,26 @@ async function renderPage(options) {
     links,
     styles,
     componentMetadata: metadata,
-    route: options.route
+    route: options.route,
+    mod,
+    env
   });
-  return await coreRenderPage(mod, ctx, options.env);
+  if (options.middleware) {
+    if (options.middleware && options.middleware.onRequest) {
+      const apiContext = createAPIContext({
+        request: options.request,
+        params: renderContext.params,
+        props: renderContext.props,
+        adapterName: options.env.adapterName
+      });
+      const onRequest = options.middleware.onRequest;
+      const response = await callMiddleware(onRequest, apiContext, () => {
+        return coreRenderPage({ mod, renderContext, env: options.env, apiContext });
+      });
+      return response;
+    }
+  }
+  return await coreRenderPage({ mod, renderContext, env: options.env });
 }
 export {
   createDevelopmentEnvironment,

package/dist/core/render/index.d.ts

@@ -1,6 +1,6 @@
 export { createRenderContext } from './context.js';
 export type { RenderContext } from './context.js';
-export { getParamsAndProps, GetParamsAndPropsError, renderPage } from './core.js';
+export { getParamsAndProps, GetParamsAndPropsError, getParamsAndPropsOrThrow, renderPage, } from './core.js';
 export type { Environment } from './environment';
 export { createBasicEnvironment, createEnvironment } from './environment.js';
 export { loadRenderer } from './renderer.js';

package/dist/core/render/index.js

@@ -1,5 +1,10 @@
 import { createRenderContext } from "./context.js";
-import { getParamsAndProps, GetParamsAndPropsError, renderPage } from "./core.js";
+import {
+  getParamsAndProps,
+  GetParamsAndPropsError,
+  getParamsAndPropsOrThrow,
+  renderPage
+} from "./core.js";
 import { createBasicEnvironment, createEnvironment } from "./environment.js";
 import { loadRenderer } from "./renderer.js";
 export {
@@ -8,6 +13,7 @@ export {
   createEnvironment,
   createRenderContext,
   getParamsAndProps,
+  getParamsAndPropsOrThrow,
   loadRenderer,
   renderPage
 };

package/dist/core/render/result.d.ts

@@ -20,5 +20,6 @@ export interface CreateResultArgs {
     componentMetadata?: SSRResult['componentMetadata'];
     request: Request;
     status: number;
+    locals: App.Locals;
 }
 export declare function createResult(args: CreateResultArgs): SSRResult;

package/dist/core/render/result.js

@@ -87,7 +87,7 @@ class Slots {
 }
 let renderMarkdown = null;
 function createResult(args) {
-  const { markdown, params, pathname, renderers, request, resolve } = args;
+  const { markdown, params, pathname, renderers, request, resolve, locals } = args;
   const url = new URL(request.url);
   const headers = new Headers();
   headers.set("Content-Type", "text/html");
@@ -141,6 +141,7 @@ function createResult(args) {
         },
         params,
         props,
+        locals,
         request,
         url,
         redirect: args.ssr ? (path, status) => {

package/dist/core/render/ssr-element.d.ts

@@ -1,7 +1,8 @@
 import type { SSRElement } from '../../@types/astro';
+import type { StylesheetAsset } from '../app/types';
 export declare function createAssetLink(href: string, base?: string, assetsPrefix?: string): string;
-export declare function createLinkStylesheetElement(href: string, base?: string, assetsPrefix?: string): SSRElement;
-export declare function createLinkStylesheetElementSet(hrefs: string[], base?: string, assetsPrefix?: string): Set<SSRElement>;
+export declare function createStylesheetElement(stylesheet: StylesheetAsset, base?: string, assetsPrefix?: string): SSRElement;
+export declare function createStylesheetElementSet(stylesheets: StylesheetAsset[], base?: string, assetsPrefix?: string): Set<SSRElement>;
 export declare function createModuleScriptElement(script: {
     type: 'inline' | 'external';
     value: string;

package/dist/core/render/ssr-element.js

@@ -9,19 +9,26 @@ function createAssetLink(href, base, assetsPrefix) {
     return href;
   }
 }
-function createLinkStylesheetElement(href, base, assetsPrefix) {
-  return {
-    props: {
-      rel: "stylesheet",
-      href: createAssetLink(href, base, assetsPrefix)
-    },
-    children: ""
-  };
+function createStylesheetElement(stylesheet, base, assetsPrefix) {
+  if (stylesheet.type === "inline") {
+    return {
+      props: {
+        type: "text/css"
+      },
+      children: stylesheet.content
+    };
+  } else {
+    return {
+      props: {
+        rel: "stylesheet",
+        href: createAssetLink(stylesheet.src, base, assetsPrefix)
+      },
+      children: ""
+    };
+  }
 }
-function createLinkStylesheetElementSet(hrefs, base, assetsPrefix) {
-  return new Set(
-    hrefs.map((href) => createLinkStylesheetElement(href, base, assetsPrefix))
-  );
+function createStylesheetElementSet(stylesheets, base, assetsPrefix) {
+  return new Set(stylesheets.map((s) => createStylesheetElement(s, base, assetsPrefix)));
 }
 function createModuleScriptElement(script, base, assetsPrefix) {
   if (script.type === "external") {
@@ -56,10 +63,10 @@ function createModuleScriptsSet(scripts, base, assetsPrefix) {
 }
 export {
   createAssetLink,
-  createLinkStylesheetElement,
-  createLinkStylesheetElementSet,
   createModuleScriptElement,
   createModuleScriptElementWithSrc,
   createModuleScriptElementWithSrcSet,
-  createModuleScriptsSet
+  createModuleScriptsSet,
+  createStylesheetElement,
+  createStylesheetElementSet
 };

package/dist/core/request.js

@@ -1,5 +1,6 @@
 import { warn } from "./logger/core.js";
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol = Symbol.for("astro.locals");
 function createRequest({
   url,
   headers,
@@ -40,6 +41,7 @@ function createRequest({
   } else if (clientAddress) {
     Reflect.set(request, clientAddressSymbol, clientAddress);
   }
+  Reflect.set(request, clientLocalsSymbol, {});
   return request;
 }
 export {

package/dist/integrations/index.js

@@ -30,7 +30,7 @@ async function runHookConfigSetup({
   let updatedConfig = { ...settings.config };
   let updatedSettings = { ...settings, config: updatedConfig };
   for (const integration of settings.config.integrations) {
-    if ((_a = integration == null ? void 0 : integration.hooks) == null ? void 0 : _a["astro:config:setup"]) {
+    if ((_a = integration.hooks) == null ? void 0 : _a["astro:config:setup"]) {
       let addPageExtension2 = function(...input) {
         const exts = input.flat(Infinity).map((ext) => `.${ext.replace(/^\./, "")}`);
         updatedSettings.pageExtensions.push(...exts);

package/dist/runtime/server/endpoint.js

@@ -12,7 +12,7 @@ function getHandlerFromModule(mod, method) {
 }
 async function renderEndpoint(mod, context, ssr) {
   var _a;
-  const { request, params } = context;
+  const { request, params, locals } = context;
   const chosenMethod = (_a = request.method) == null ? void 0 : _a.toLowerCase();
   const handler = getHandlerFromModule(mod, chosenMethod);
   if (!ssr && ssr === false && chosenMethod && chosenMethod !== "get") {

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, markHTMLString, unescapeHTML } from './escape.js';
 export { renderJSX } from './jsx.js';
-export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderSlotToString, renderStyleElement, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, stringifyChunk, voidElementNames, } from './render/index.js';
+export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderSlotToString, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, stringifyChunk, voidElementNames, } from './render/index.js';
 export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;
 /** @internal Associate JSX components with a specific renderer (see /src/vite-plugin-jsx/tag.ts) */

package/dist/runtime/server/index.js

@@ -19,7 +19,6 @@ import {
   renderScriptElement,
   renderSlot,
   renderSlotToString,
-  renderStyleElement,
   renderTemplate,
   renderTemplate as renderTemplate2,
   renderToString,
@@ -109,7 +108,6 @@ export {
   renderScriptElement,
   renderSlot,
   renderSlotToString,
-  renderStyleElement,
   renderTemplate2 as renderTemplate,
   renderToString,
   renderUniqueStylesheet,

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

@@ -7,7 +7,9 @@ const uniqueElements = (item, index, all) => {
 };
 function renderAllHeadContent(result) {
   result._metadata.hasRenderedHead = true;
-  const styles = Array.from(result.styles).filter(uniqueElements).map((style) => renderElement("style", style));
+  const styles = Array.from(result.styles).filter(uniqueElements).map(
+    (style) => style.props.rel === "stylesheet" ? renderElement("link", style) : renderElement("style", style)
+  );
   result.styles.clear();
   const scripts = Array.from(result.scripts).filter(uniqueElements).map((script, i) => {
     return renderElement("script", script, false);

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

@@ -6,6 +6,6 @@ export { renderHTMLElement } from './dom.js';
 export { maybeRenderHead, renderHead } from './head.js';
 export { renderPage } from './page.js';
 export { renderSlot, renderSlotToString, type ComponentSlots } from './slot.js';
-export { renderScriptElement, renderStyleElement, renderUniqueStylesheet } from './tags.js';
+export { renderScriptElement, renderUniqueStylesheet } from './tags.js';
 export type { RenderInstruction } from './types';
 export { addAttribute, defineScriptVars, voidElementNames } from './util.js';

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

@@ -10,7 +10,7 @@ import { renderHTMLElement } from "./dom.js";
 import { maybeRenderHead, renderHead } from "./head.js";
 import { renderPage } from "./page.js";
 import { renderSlot, renderSlotToString } from "./slot.js";
-import { renderScriptElement, renderStyleElement, renderUniqueStylesheet } from "./tags.js";
+import { renderScriptElement, renderUniqueStylesheet } from "./tags.js";
 import { addAttribute, defineScriptVars, voidElementNames } from "./util.js";
 export {
   Fragment,
@@ -28,7 +28,6 @@ export {
   renderScriptElement,
   renderSlot,
   renderSlotToString,
-  renderStyleElement,
   renderTemplate,
   renderToString,
   renderUniqueStylesheet,

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

@@ -1,9 +1,4 @@
 import type { SSRElement, SSRResult } from '../../../@types/astro';
-export declare function renderStyleElement(children: string): string;
+import type { StylesheetAsset } from '../../../core/app/types';
 export declare function renderScriptElement({ props, children }: SSRElement): string;
-export declare function renderStylesheet({ href }: {
-    href: string;
-}): string;
-export declare function renderUniqueStylesheet(result: SSRResult, link: {
-    href: string;
-}): string;
+export declare function renderUniqueStylesheet(result: SSRResult, sheet: StylesheetAsset): string | undefined;