astro 1.5.0 → 1.5.2

package/dist/core/render/core.js

@@ -1,4 +1,4 @@
-import { Fragment, renderPage } from "../../runtime/server/index.js";
+import { Fragment, renderPage as runtimeRenderPage } from "../../runtime/server/index.js";
 import { attachToResponse } from "../cookies/index.js";
 import { getParams } from "../routing/params.js";
 import { createResult } from "./result.js";
@@ -33,63 +33,42 @@ async function getParamsAndProps(opts) {
   }
   return [params, pageProps];
 }
-async function render(opts) {
-  const {
-    adapterName,
-    links,
-    styles,
-    logging,
-    origin,
-    markdown,
-    mod,
-    mode,
-    pathname,
-    scripts,
-    renderers,
-    request,
-    resolve,
-    route,
-    routeCache,
-    site,
-    ssr,
-    streaming,
-    status = 200
-  } = opts;
+async function renderPage(mod, ctx, env) {
   const paramsAndPropsRes = await getParamsAndProps({
-    logging,
+    logging: env.logging,
     mod,
-    route,
-    routeCache,
-    pathname,
-    ssr
+    route: ctx.route,
+    routeCache: env.routeCache,
+    pathname: ctx.pathname,
+    ssr: env.ssr
   });
   if (paramsAndPropsRes === 0 /* NoMatchingStaticPath */) {
     throw new Error(
-      `[getStaticPath] route pattern matched, but no matching static path found. (${pathname})`
+      `[getStaticPath] route pattern matched, but no matching static path found. (${ctx.pathname})`
     );
   }
   const [params, pageProps] = paramsAndPropsRes;
-  const Component = await mod.default;
+  const Component = mod.default;
   if (!Component)
     throw new Error(`Expected an exported Astro component but received typeof ${typeof Component}`);
   const result = createResult({
-    adapterName,
-    links,
-    styles,
-    logging,
-    markdown,
-    mode,
-    origin,
+    adapterName: env.adapterName,
+    links: ctx.links,
+    styles: ctx.styles,
+    logging: env.logging,
+    markdown: env.markdown,
+    mode: env.mode,
+    origin: ctx.origin,
     params,
     props: pageProps,
-    pathname,
-    resolve,
-    renderers,
-    request,
-    site,
-    scripts,
-    ssr,
-    status
+    pathname: ctx.pathname,
+    resolve: env.resolve,
+    renderers: env.renderers,
+    request: ctx.request,
+    site: env.site,
+    scripts: ctx.scripts,
+    ssr: env.ssr,
+    status: ctx.status ?? 200
   });
   if (typeof mod.components === "object") {
     Object.assign(pageProps, { components: mod.components });
@@ -99,7 +78,7 @@ async function render(opts) {
       components: Object.assign((pageProps == null ? void 0 : pageProps.components) ?? {}, { Fragment })
     });
   }
-  const response = await renderPage(result, Component, pageProps, null, streaming);
+  const response = await runtimeRenderPage(result, Component, pageProps, null, env.streaming);
   if (result.cookies) {
     attachToResponse(response, result.cookies);
   }
@@ -108,5 +87,5 @@ async function render(opts) {
 export {
   GetParamsAndPropsError,
   getParamsAndProps,
-  render
+  renderPage
 };

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

@@ -0,0 +1,9 @@
+import type { ViteDevServer } from 'vite';
+import type { AstroSettings } from '../../../@types/astro';
+import type { LogOptions } from '../../logger/core.js';
+import type { Environment } from '../index';
+export declare type DevelopmentEnvironment = Environment & {
+    settings: AstroSettings;
+    viteServer: ViteDevServer;
+};
+export declare function createDevelopmentEnvironment(settings: AstroSettings, logging: LogOptions, viteServer: ViteDevServer): DevelopmentEnvironment;

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

@@ -0,0 +1,30 @@
+import { createEnvironment } from "../index.js";
+import { RouteCache } from "../route-cache.js";
+import { createResolve } from "./resolve.js";
+function createDevelopmentEnvironment(settings, logging, viteServer) {
+  var _a;
+  const mode = "development";
+  let env = createEnvironment({
+    adapterName: (_a = settings.adapter) == null ? void 0 : _a.name,
+    logging,
+    markdown: {
+      ...settings.config.markdown,
+      isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
+    },
+    mode,
+    renderers: [],
+    resolve: createResolve(viteServer),
+    routeCache: new RouteCache(logging, mode),
+    site: settings.config.site,
+    ssr: settings.config.output === "server",
+    streaming: true
+  });
+  return {
+    ...env,
+    viteServer,
+    settings
+  };
+}
+export {
+  createDevelopmentEnvironment
+};

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

@@ -2,7 +2,10 @@ import type { ViteDevServer } from 'vite';
 import type { AstroSettings, ComponentInstance, RouteData, RuntimeMode, SSRLoadedRenderer } from '../../../@types/astro';
 import { LogOptions } from '../../logger/core.js';
 import { RouteCache } from '../route-cache.js';
-export interface SSROptions {
+import type { DevelopmentEnvironment } from './environment';
+export { createDevelopmentEnvironment } from './environment.js';
+export type { DevelopmentEnvironment };
+export interface SSROptionsOld {
     /** an instance of the AstroSettings */
     settings: AstroSettings;
     /** location of file on disk */
@@ -24,9 +27,23 @@ export interface SSROptions {
     /** Request */
     request: Request;
 }
+export interface SSROptions {
+    /** The environment instance */
+    env: DevelopmentEnvironment;
+    /** location of file on disk */
+    filePath: URL;
+    /** production website */
+    origin: string;
+    /** the web request (needed for dynamic routes) */
+    pathname: string;
+    /** The renderers and instance */
+    preload: ComponentPreload;
+    /** Request */
+    request: Request;
+    /** optional, in case we need to render something outside of a dev server */
+    route?: RouteData;
+}
 export declare type ComponentPreload = [SSRLoadedRenderer[], ComponentInstance];
 export declare function loadRenderers(viteServer: ViteDevServer, settings: AstroSettings): Promise<SSRLoadedRenderer[]>;
-export declare function preload({ settings, filePath, viteServer, }: Pick<SSROptions, 'settings' | 'filePath' | 'viteServer'>): Promise<ComponentPreload>;
-/** use Vite to SSR */
-export declare function render(renderers: SSRLoadedRenderer[], mod: ComponentInstance, ssrOpts: SSROptions): Promise<Response>;
-export declare function ssr(preloadedComponent: ComponentPreload, ssrOpts: SSROptions): Promise<Response>;
+export declare function preload({ env, filePath, }: Pick<SSROptions, 'env' | 'filePath'>): Promise<ComponentPreload>;
+export declare function renderPage(options: SSROptions): Promise<Response>;

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

@@ -1,50 +1,35 @@
 import { fileURLToPath } from "url";
 import { PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
 import { isPage, resolveIdToUrl } from "../../util.js";
-import { render as coreRender } from "../core.js";
+import { createRenderContext, renderPage as coreRenderPage } from "../index.js";
+import { filterFoundRenderers, loadRenderer } from "../renderer.js";
 import { collectMdMetadata } from "../util.js";
 import { getStylesForURL } from "./css.js";
 import { getScriptsForURL } from "./scripts.js";
-const svelteStylesRE = /svelte\?svelte&type=style/;
-async function loadRenderer(viteServer, renderer) {
-  const mod = await viteServer.ssrLoadModule(renderer.serverEntrypoint);
-  return { ...renderer, ssr: mod.default };
-}
+import { createDevelopmentEnvironment } from "./environment.js";
 async function loadRenderers(viteServer, settings) {
-  return Promise.all(settings.renderers.map((r) => loadRenderer(viteServer, r)));
+  const loader = (entry) => viteServer.ssrLoadModule(entry);
+  const renderers = await Promise.all(settings.renderers.map((r) => loadRenderer(r, loader)));
+  return filterFoundRenderers(renderers);
 }
 async function preload({
-  settings,
-  filePath,
-  viteServer
+  env,
+  filePath
 }) {
-  const renderers = await loadRenderers(viteServer, settings);
-  const mod = await viteServer.ssrLoadModule(fileURLToPath(filePath));
-  if (viteServer.config.mode === "development" || !(mod == null ? void 0 : mod.$$metadata)) {
+  const renderers = await loadRenderers(env.viteServer, env.settings);
+  const mod = await env.viteServer.ssrLoadModule(fileURLToPath(filePath));
+  if (env.viteServer.config.mode === "development" || !(mod == null ? void 0 : mod.$$metadata)) {
     return [renderers, mod];
   }
-  const modGraph = await viteServer.moduleGraph.getModuleByUrl(fileURLToPath(filePath));
+  const modGraph = await env.viteServer.moduleGraph.getModuleByUrl(fileURLToPath(filePath));
   if (modGraph) {
-    await collectMdMetadata(mod.$$metadata, modGraph, viteServer);
+    await collectMdMetadata(mod.$$metadata, modGraph, env.viteServer);
   }
   return [renderers, mod];
 }
-async function render(renderers, mod, ssrOpts) {
-  var _a;
-  const {
-    settings,
-    filePath,
-    logging,
-    mode,
-    origin,
-    pathname,
-    request,
-    route,
-    routeCache,
-    viteServer
-  } = ssrOpts;
-  const scripts = await getScriptsForURL(filePath, viteServer);
-  if (isPage(filePath, settings) && mode === "development") {
+async function getScriptsAndStyles({ env, filePath }) {
+  const scripts = await getScriptsForURL(filePath, env.viteServer);
+  if (isPage(filePath, env.settings) && env.mode === "development") {
     scripts.add({
       props: { type: "module", src: "/@vite/client" },
       children: ""
@@ -52,25 +37,25 @@ async function render(renderers, mod, ssrOpts) {
     scripts.add({
       props: {
         type: "module",
-        src: await resolveIdToUrl(viteServer, "astro/runtime/client/hmr.js")
+        src: await resolveIdToUrl(env.viteServer, "astro/runtime/client/hmr.js")
       },
       children: ""
     });
   }
-  for (const script of settings.scripts) {
+  for (const script of env.settings.scripts) {
     if (script.stage === "head-inline") {
       scripts.add({
         props: {},
         children: script.content
       });
-    } else if (script.stage === "page" && isPage(filePath, settings)) {
+    } else if (script.stage === "page" && isPage(filePath, env.settings)) {
       scripts.add({
         props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
         children: ""
       });
     }
   }
-  const { urls: styleUrls, stylesMap } = await getStylesForURL(filePath, viteServer, mode);
+  const { urls: styleUrls, stylesMap } = await getStylesForURL(filePath, env.viteServer, env.mode);
   let links = /* @__PURE__ */ new Set();
   [...styleUrls].forEach((href) => {
     links.add({
@@ -95,45 +80,29 @@ async function render(renderers, mod, ssrOpts) {
       children: content
     });
   });
-  let response = await coreRender({
-    adapterName: (_a = settings.config.adapter) == null ? void 0 : _a.name,
+  return { scripts, styles, links };
+}
+async function renderPage(options) {
+  const [renderers, mod] = options.preload;
+  options.env.renderers = renderers;
+  const { scripts, links, styles } = await getScriptsAndStyles({
+    env: options.env,
+    filePath: options.filePath
+  });
+  const ctx = createRenderContext({
+    request: options.request,
+    origin: options.origin,
+    pathname: options.pathname,
+    scripts,
     links,
     styles,
-    logging,
-    markdown: {
-      ...settings.config.markdown,
-      isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
-    },
-    mod,
-    mode,
-    origin,
-    pathname,
-    scripts,
-    async resolve(s) {
-      const url = await resolveIdToUrl(viteServer, s);
-      if (url.startsWith("/@fs") && url.endsWith(".jsx")) {
-        return url.slice(0, -4);
-      } else {
-        return url;
-      }
-    },
-    renderers,
-    request,
-    route,
-    routeCache,
-    site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : void 0,
-    ssr: settings.config.output === "server",
-    streaming: true
+    route: options.route
   });
-  return response;
-}
-async function ssr(preloadedComponent, ssrOpts) {
-  const [renderers, mod] = preloadedComponent;
-  return await render(renderers, mod, ssrOpts);
+  return await coreRenderPage(mod, ctx, options.env);
 }
 export {
+  createDevelopmentEnvironment,
   loadRenderers,
   preload,
-  render,
-  ssr
+  renderPage
 };

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

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from 'vite';
+export declare function createResolve(viteServer: ViteDevServer): (s: string) => Promise<string>;

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

@@ -0,0 +1,14 @@
+import { resolveIdToUrl } from "../../util.js";
+function createResolve(viteServer) {
+  return async function(s) {
+    const url = await resolveIdToUrl(viteServer, s);
+    if (url.startsWith("/@fs") && url.endsWith(".jsx")) {
+      return url.slice(0, -4);
+    } else {
+      return url;
+    }
+  };
+}
+export {
+  createResolve
+};

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

@@ -0,0 +1,29 @@
+import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
+import type { RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
+import type { LogOptions } from '../logger/core.js';
+import { RouteCache } from './route-cache.js';
+/**
+ * An environment represents the static parts of rendering that do not change
+ * between requests. These are mostly known when the server first starts up and do not change.
+ * Thus they can be created once and passed through to renderPage on each request.
+ */
+export interface Environment {
+    adapterName?: string;
+    /** logging options */
+    logging: LogOptions;
+    markdown: MarkdownRenderingOptions;
+    /** "development" or "production" */
+    mode: RuntimeMode;
+    renderers: SSRLoadedRenderer[];
+    resolve: (s: string) => Promise<string>;
+    routeCache: RouteCache;
+    site?: string;
+    ssr: boolean;
+    streaming: boolean;
+}
+export declare type CreateEnvironmentArgs = Environment;
+export declare function createEnvironment(options: CreateEnvironmentArgs): Environment;
+export declare type CreateBasicEnvironmentArgs = Partial<Environment> & {
+    logging: CreateEnvironmentArgs['logging'];
+};
+export declare function createBasicEnvironment(options: CreateBasicEnvironmentArgs): Environment;

package/dist/core/render/environment.js

@@ -0,0 +1,21 @@
+import { RouteCache } from "./route-cache.js";
+function createEnvironment(options) {
+  return options;
+}
+function createBasicEnvironment(options) {
+  const mode = options.mode ?? "development";
+  return createEnvironment({
+    ...options,
+    markdown: options.markdown ?? {},
+    mode,
+    renderers: options.renderers ?? [],
+    resolve: options.resolve ?? ((s) => Promise.resolve(s)),
+    routeCache: new RouteCache(options.logging, mode),
+    ssr: options.ssr ?? true,
+    streaming: options.streaming ?? true
+  });
+}
+export {
+  createBasicEnvironment,
+  createEnvironment
+};

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

@@ -0,0 +1,6 @@
+export type { RenderContext } from './context';
+export { createRenderContext } from './context.js';
+export { getParamsAndProps, GetParamsAndPropsError, 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

@@ -0,0 +1,13 @@
+import { createRenderContext } from "./context.js";
+import { getParamsAndProps, GetParamsAndPropsError, renderPage } from "./core.js";
+import { createBasicEnvironment, createEnvironment } from "./environment.js";
+import { loadRenderer } from "./renderer.js";
+export {
+  GetParamsAndPropsError,
+  createBasicEnvironment,
+  createEnvironment,
+  createRenderContext,
+  getParamsAndProps,
+  loadRenderer,
+  renderPage
+};

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

@@ -0,0 +1,9 @@
+import type { AstroRenderer, SSRLoadedRenderer } from '../../@types/astro';
+export declare type RendererServerEntrypointModule = {
+    default: SSRLoadedRenderer['ssr'];
+};
+export declare type MaybeRendererServerEntrypointModule = Partial<RendererServerEntrypointModule>;
+export declare type RendererLoader = (entryPoint: string) => Promise<MaybeRendererServerEntrypointModule>;
+export declare function loadRenderer(renderer: AstroRenderer, loader: RendererLoader): Promise<SSRLoadedRenderer | undefined>;
+export declare function filterFoundRenderers(renderers: Array<SSRLoadedRenderer | undefined>): SSRLoadedRenderer[];
+export declare function createLoadedRenderer(renderer: AstroRenderer, mod: RendererServerEntrypointModule): SSRLoadedRenderer;

package/dist/core/render/renderer.js

@@ -0,0 +1,23 @@
+async function loadRenderer(renderer, loader) {
+  const mod = await loader(renderer.serverEntrypoint);
+  if (typeof mod.default !== "undefined") {
+    return createLoadedRenderer(renderer, mod);
+  }
+  return void 0;
+}
+function filterFoundRenderers(renderers) {
+  return renderers.filter((renderer) => {
+    return !!renderer;
+  });
+}
+function createLoadedRenderer(renderer, mod) {
+  return {
+    ...renderer,
+    ssr: mod.default
+  };
+}
+export {
+  createLoadedRenderer,
+  filterFoundRenderers,
+  loadRenderer
+};

package/dist/core/render/result.js

@@ -116,7 +116,7 @@ _slots = new WeakMap();
 _loggingOpts = new WeakMap();
 let renderMarkdown = null;
 function createResult(args) {
-  const { markdown, params, pathname, props: pageProps, renderers, request, resolve } = args;
+  const { markdown, params, pathname, renderers, request, resolve } = args;
   const url = new URL(request.url);
   const headers = new Headers();
   headers.set("Content-Type", "text/html");

package/dist/core/routing/manifest/create.js

@@ -36,10 +36,19 @@ function getParts(part, file) {
 }
 function getPattern(segments, addTrailingSlash) {
   const pathname = segments.map((segment) => {
-    return segment[0].spread ? "(?:\\/(.*?))?" : "\\/" + segment.map((part) => {
-      if (part)
-        return part.dynamic ? "([^/]+?)" : part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }).join("");
+    if (segment.length === 1 && segment[0].spread) {
+      return "(?:\\/(.*?))?";
+    } else {
+      return "\\/" + segment.map((part) => {
+        if (part.spread) {
+          return "(.*?)";
+        } else if (part.dynamic) {
+          return "([^/]+?)";
+        } else {
+          return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+      }).join("");
+    }
   }).join("");
   const trailing = addTrailingSlash && segments.length ? getTrailingSlashPattern(addTrailingSlash) : "$";
   return new RegExp(`^${pathname || "\\/"}${trailing}`);
@@ -71,7 +80,7 @@ function validateSegment(segment, file = "") {
   if (countOccurrences("[", segment) !== countOccurrences("]", segment)) {
     throw new Error(`Invalid route ${file} \u2014 brackets are unbalanced`);
   }
-  if (/.+\[\.\.\.[^\]]+\]/.test(segment) || /\[\.\.\.[^\]]+\].+/.test(segment)) {
+  if ((/.+\[\.\.\.[^\]]+\]/.test(segment) || /\[\.\.\.[^\]]+\].+/.test(segment)) && file.endsWith(".astro")) {
     throw new Error(`Invalid route ${file} \u2014 rest parameter must be a standalone segment`);
   }
 }

package/dist/core/routing/manifest/generator.js

@@ -1,9 +1,14 @@
 import { compile } from "path-to-regexp";
 function getRouteGenerator(segments, addTrailingSlash) {
   const template = segments.map((segment) => {
-    return segment[0].spread ? `/:${segment[0].content.slice(3)}(.*)?` : "/" + segment.map((part) => {
-      if (part)
-        return part.dynamic ? `:${part.content}` : part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return "/" + segment.map((part) => {
+      if (part.spread) {
+        return `:${part.content.slice(3)}(.*)?`;
+      } else if (part.dynamic) {
+        return `:${part.content}`;
+      } else {
+        return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
     }).join("");
   }).join("");
   let trailing = "";

package/dist/jsx/component.d.ts

@@ -0,0 +1 @@
+export declare function createAstroJSXComponent(factory: (...args: any[]) => any): (...args: any[]) => any;

package/dist/jsx/component.js

@@ -0,0 +1,10 @@
+import { __astro_tag_component__ } from "../runtime/server/index.js";
+import renderer from "./renderer.js";
+const ASTRO_JSX_RENDERER_NAME = renderer.name;
+function createAstroJSXComponent(factory) {
+  __astro_tag_component__(factory, ASTRO_JSX_RENDERER_NAME);
+  return factory;
+}
+export {
+  createAstroJSXComponent
+};

package/dist/jsx/index.d.ts

@@ -0,0 +1,2 @@
+export { createAstroJSXComponent } from './component.js';
+export { default as renderer } from './renderer.js';

package/dist/jsx/index.js

@@ -0,0 +1,6 @@
+import { createAstroJSXComponent } from "./component.js";
+import { default as default2 } from "./renderer.js";
+export {
+  createAstroJSXComponent,
+  default2 as renderer
+};

package/dist/jsx-runtime/index.js

@@ -1,7 +1,7 @@
 import { Fragment, markHTMLString, Renderer } from "../runtime/server/index.js";
 const AstroJSX = "astro:jsx";
 const Empty = Symbol("empty");
-const toSlotName = (str) => str.trim().replace(/[-_]([a-z])/g, (_, w) => w.toUpperCase());
+const toSlotName = (slotAttr) => slotAttr;
 function isVNode(vnode) {
   return vnode && typeof vnode === "object" && vnode[AstroJSX];
 }

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

@@ -1,6 +1,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 type { Metadata } from './metadata';
 export { createMetadata } from './metadata.js';
 export { addAttribute, defineScriptVars, Fragment, maybeRenderHead, renderAstroComponent, renderComponent, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderSlot, renderTemplate as render, renderTemplate, renderToString, stringifyChunk, voidElementNames, } from './render/index.js';

package/dist/runtime/server/index.js

@@ -1,6 +1,7 @@
 import { createAstro } from "./astro-global.js";
 import { renderEndpoint } from "./endpoint.js";
 import { escapeHTML, HTMLBytes, HTMLString, markHTMLString, unescapeHTML } from "./escape.js";
+import { renderJSX } from "./jsx.js";
 import { createMetadata } from "./metadata.js";
 import {
   addAttribute,
@@ -101,6 +102,7 @@ export {
   renderEndpoint,
   renderHTMLElement,
   renderHead,
+  renderJSX,
   renderPage,
   renderSlot,
   renderTemplate2 as renderTemplate,