astro 1.4.7 → 1.5.1

package/dist/core/preview/index.js

@@ -1,134 +1,40 @@
-import fs from "fs";
-import http from "http";
-import { performance } from "perf_hooks";
-import sirv from "sirv";
-import { fileURLToPath } from "url";
-import { notFoundTemplate, subpathNotUsedTemplate } from "../../template/4xx.js";
-import { error, info } from "../logger/core.js";
-import * as msg from "../messages.js";
+import { createRequire } from "module";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/index.js";
+import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
-const HAS_FILE_EXTENSION_REGEXP = /^.*\.[^\\]+$/;
-async function preview(settings, { logging }) {
-  if (settings.config.output === "server") {
-    throw new Error(
-      `[preview] 'output: server' not supported. Use your deploy platform's preview command directly instead, if one exists. (ex: 'netlify dev', 'vercel dev', 'wrangler', etc.)`
-    );
-  }
-  const startServerTime = performance.now();
-  const defaultOrigin = "http://localhost";
-  const trailingSlash = settings.config.trailingSlash;
-  let baseURL = new URL(settings.config.base, new URL(settings.config.site || "/", defaultOrigin));
-  const staticFileServer = sirv(fileURLToPath(settings.config.outDir), {
-    dev: true,
-    etag: true,
-    maxAge: 0
-  });
-  const server = http.createServer((req, res) => {
-    var _a;
-    const requestURL = new URL(req.url, defaultOrigin);
-    if (!requestURL.pathname.startsWith(baseURL.pathname)) {
-      res.statusCode = 404;
-      res.end(subpathNotUsedTemplate(baseURL.pathname, requestURL.pathname));
-      return;
-    }
-    const pathname = requestURL.pathname.slice(baseURL.pathname.length - 1);
-    const isRoot = pathname === "/";
-    const hasTrailingSlash = isRoot || pathname.endsWith("/");
-    function sendError(message) {
-      res.statusCode = 404;
-      res.end(notFoundTemplate(pathname, message));
-    }
-    switch (true) {
-      case (hasTrailingSlash && trailingSlash == "never" && !isRoot):
-        sendError('Not Found (trailingSlash is set to "never")');
-        return;
-      case (!hasTrailingSlash && trailingSlash == "always" && !isRoot && !HAS_FILE_EXTENSION_REGEXP.test(pathname)):
-        sendError('Not Found (trailingSlash is set to "always")');
-        return;
-      default: {
-        req.url = "/" + ((_a = req.url) == null ? void 0 : _a.replace(baseURL.pathname, ""));
-        staticFileServer(req, res, () => {
-          const errorPagePath = fileURLToPath(settings.config.outDir + "/404.html");
-          if (fs.existsSync(errorPagePath)) {
-            res.statusCode = 404;
-            res.setHeader("Content-Type", "text/html;charset=utf-8");
-            res.end(fs.readFileSync(errorPagePath));
-          } else {
-            staticFileServer(req, res, () => {
-              sendError("Not Found");
-            });
-          }
-        });
-        return;
-      }
-    }
+async function preview(_settings, { logging }) {
+  const settings = await runHookConfigSetup({
+    settings: _settings,
+    command: "preview",
+    logging
   });
-  let { port } = settings.config.server;
+  await runHookConfigDone({ settings, logging });
   const host = getResolvedHostForHttpServer(settings.config.server.host);
-  let httpServer;
-  function startServer(timerStart) {
-    let showedPortTakenMsg = false;
-    let showedListenMsg = false;
-    return new Promise((resolve, reject) => {
-      const listen = () => {
-        httpServer = server.listen(port, host, async () => {
-          if (!showedListenMsg) {
-            const resolvedUrls = msg.resolveServerUrls({
-              address: server.address(),
-              host: settings.config.server.host,
-              https: false
-            });
-            info(
-              logging,
-              null,
-              msg.serverStart({
-                startupTime: performance.now() - timerStart,
-                resolvedUrls,
-                host: settings.config.server.host,
-                site: baseURL
-              })
-            );
-          }
-          showedListenMsg = true;
-          resolve();
-        });
-        httpServer == null ? void 0 : httpServer.on("error", onError);
-      };
-      const onError = (err) => {
-        if (err.code && err.code === "EADDRINUSE") {
-          if (!showedPortTakenMsg) {
-            info(logging, "astro", msg.portInUse({ port }));
-            showedPortTakenMsg = true;
-          }
-          port++;
-          return listen();
-        } else {
-          error(logging, "astro", err.stack || err.message);
-          httpServer == null ? void 0 : httpServer.removeListener("error", onError);
-          reject(err);
-        }
-      };
-      listen();
-    });
+  const { port } = settings.config.server;
+  if (settings.config.output === "static") {
+    const server2 = await createStaticPreviewServer(settings, { logging, host, port });
+    return server2;
+  }
+  if (!settings.adapter) {
+    throw new Error(`[preview] No adapter found.`);
   }
-  await startServer(startServerTime);
-  function closed() {
-    return new Promise((resolve, reject) => {
-      httpServer.addListener("close", resolve);
-      httpServer.addListener("error", reject);
-    });
+  if (!settings.adapter.previewEntrypoint) {
+    throw new Error(`[preview] adapter does not have previewEntrypoint.`);
   }
-  return {
+  const require2 = createRequire(settings.config.root);
+  const previewEntrypoint = require2.resolve(settings.adapter.previewEntrypoint);
+  const previewModule = await import(previewEntrypoint);
+  if (typeof previewModule.default !== "function") {
+    throw new Error(`[preview] ${settings.adapter.name} cannot preview your app.`);
+  }
+  const server = await previewModule.default({
+    outDir: settings.config.outDir,
+    client: settings.config.build.client,
+    serverEntrypoint: new URL(settings.config.build.serverEntry, settings.config.build.server),
     host,
-    port,
-    closed,
-    server: httpServer,
-    stop: async () => {
-      await new Promise((resolve, reject) => {
-        httpServer.close((err) => err ? reject(err) : resolve(void 0));
-      });
-    }
-  };
+    port
+  });
+  return server;
 }
 export {
   preview as default

package/dist/core/preview/static-preview-server.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { AstroSettings } from '../../@types/astro';
+import type { LogOptions } from '../logger/core';
+import http from 'http';
+export interface PreviewServer {
+    host?: string;
+    port: number;
+    server: http.Server;
+    closed(): Promise<void>;
+    stop(): Promise<void>;
+}
+/** The primary dev action */
+export default function createStaticPreviewServer(settings: AstroSettings, { logging, host, port }: {
+    logging: LogOptions;
+    host: string | undefined;
+    port: number;
+}): Promise<PreviewServer>;

package/dist/core/preview/static-preview-server.js

@@ -0,0 +1,127 @@
+import fs from "fs";
+import http from "http";
+import { performance } from "perf_hooks";
+import sirv from "sirv";
+import { fileURLToPath } from "url";
+import { notFoundTemplate, subpathNotUsedTemplate } from "../../template/4xx.js";
+import { error, info } from "../logger/core.js";
+import * as msg from "../messages.js";
+const HAS_FILE_EXTENSION_REGEXP = /^.*\.[^\\]+$/;
+async function createStaticPreviewServer(settings, { logging, host, port }) {
+  const startServerTime = performance.now();
+  const defaultOrigin = "http://localhost";
+  const trailingSlash = settings.config.trailingSlash;
+  let baseURL = new URL(settings.config.base, new URL(settings.config.site || "/", defaultOrigin));
+  const staticFileServer = sirv(fileURLToPath(settings.config.outDir), {
+    dev: true,
+    etag: true,
+    maxAge: 0
+  });
+  const server = http.createServer((req, res) => {
+    var _a;
+    const requestURL = new URL(req.url, defaultOrigin);
+    if (!requestURL.pathname.startsWith(baseURL.pathname)) {
+      res.statusCode = 404;
+      res.end(subpathNotUsedTemplate(baseURL.pathname, requestURL.pathname));
+      return;
+    }
+    const pathname = requestURL.pathname.slice(baseURL.pathname.length - 1);
+    const isRoot = pathname === "/";
+    const hasTrailingSlash = isRoot || pathname.endsWith("/");
+    function sendError(message) {
+      res.statusCode = 404;
+      res.end(notFoundTemplate(pathname, message));
+    }
+    switch (true) {
+      case (hasTrailingSlash && trailingSlash == "never" && !isRoot):
+        sendError('Not Found (trailingSlash is set to "never")');
+        return;
+      case (!hasTrailingSlash && trailingSlash == "always" && !isRoot && !HAS_FILE_EXTENSION_REGEXP.test(pathname)):
+        sendError('Not Found (trailingSlash is set to "always")');
+        return;
+      default: {
+        req.url = "/" + ((_a = req.url) == null ? void 0 : _a.replace(baseURL.pathname, ""));
+        staticFileServer(req, res, () => {
+          const errorPagePath = fileURLToPath(settings.config.outDir + "/404.html");
+          if (fs.existsSync(errorPagePath)) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "text/html;charset=utf-8");
+            res.end(fs.readFileSync(errorPagePath));
+          } else {
+            staticFileServer(req, res, () => {
+              sendError("Not Found");
+            });
+          }
+        });
+        return;
+      }
+    }
+  });
+  let httpServer;
+  function startServer(timerStart) {
+    let showedPortTakenMsg = false;
+    let showedListenMsg = false;
+    return new Promise((resolve, reject) => {
+      const listen = () => {
+        httpServer = server.listen(port, host, async () => {
+          if (!showedListenMsg) {
+            const resolvedUrls = msg.resolveServerUrls({
+              address: server.address(),
+              host: settings.config.server.host,
+              https: false
+            });
+            info(
+              logging,
+              null,
+              msg.serverStart({
+                startupTime: performance.now() - timerStart,
+                resolvedUrls,
+                host: settings.config.server.host,
+                site: baseURL
+              })
+            );
+          }
+          showedListenMsg = true;
+          resolve();
+        });
+        httpServer == null ? void 0 : httpServer.on("error", onError);
+      };
+      const onError = (err) => {
+        if (err.code && err.code === "EADDRINUSE") {
+          if (!showedPortTakenMsg) {
+            info(logging, "astro", msg.portInUse({ port }));
+            showedPortTakenMsg = true;
+          }
+          port++;
+          return listen();
+        } else {
+          error(logging, "astro", err.stack || err.message);
+          httpServer == null ? void 0 : httpServer.removeListener("error", onError);
+          reject(err);
+        }
+      };
+      listen();
+    });
+  }
+  await startServer(startServerTime);
+  function closed() {
+    return new Promise((resolve, reject) => {
+      httpServer.addListener("close", resolve);
+      httpServer.addListener("error", reject);
+    });
+  }
+  return {
+    host,
+    port,
+    closed,
+    server: httpServer,
+    stop: async () => {
+      await new Promise((resolve, reject) => {
+        httpServer.close((err) => err ? reject(err) : resolve(void 0));
+      });
+    }
+  };
+}
+export {
+  createStaticPreviewServer as default
+};

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

@@ -0,0 +1,20 @@
+import type { RouteData, SSRElement } from '../../@types/astro';
+/**
+ * The RenderContext represents the parts of rendering that are specific to one request.
+ */
+export interface RenderContext {
+    request: Request;
+    origin: string;
+    pathname: string;
+    url: URL;
+    scripts?: Set<SSRElement>;
+    links?: Set<SSRElement>;
+    styles?: Set<SSRElement>;
+    route?: RouteData;
+    status?: number;
+}
+export declare type CreateRenderContextArgs = Partial<RenderContext> & {
+    origin?: string;
+    request: RenderContext['request'];
+};
+export declare function createRenderContext(options: CreateRenderContextArgs): RenderContext;

package/dist/core/render/context.js

@@ -0,0 +1,15 @@
+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;
+  return {
+    ...options,
+    origin,
+    pathname,
+    url
+  };
+}
+export {
+  createRenderContext
+};

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

@@ -1,6 +1,7 @@
-import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
-import type { ComponentInstance, Params, Props, RouteData, RuntimeMode, SSRElement, SSRLoadedRenderer } from '../../@types/astro';
+import type { 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';
 import { RouteCache } from './route-cache.js';
 interface GetParamsAndPropsOptions {
     mod: ComponentInstance;
@@ -14,26 +15,5 @@ export declare const enum GetParamsAndPropsError {
     NoMatchingStaticPath = 0
 }
 export declare function getParamsAndProps(opts: GetParamsAndPropsOptions): Promise<[Params, Props] | GetParamsAndPropsError>;
-export interface RenderOptions {
-    adapterName: string | undefined;
-    logging: LogOptions;
-    links: Set<SSRElement>;
-    styles?: Set<SSRElement>;
-    markdown: MarkdownRenderingOptions;
-    mod: ComponentInstance;
-    mode: RuntimeMode;
-    origin: string;
-    pathname: string;
-    scripts: Set<SSRElement>;
-    resolve: (s: string) => Promise<string>;
-    renderers: SSRLoadedRenderer[];
-    route?: RouteData;
-    routeCache: RouteCache;
-    site?: string;
-    ssr: boolean;
-    streaming: boolean;
-    request: Request;
-    status?: number;
-}
-export declare function render(opts: RenderOptions): Promise<Response>;
+export declare function renderPage(mod: ComponentInstance, ctx: RenderContext, env: Environment): Promise<Response>;
 export {};

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>;