astro 1.5.0 → 1.5.1

package/astro-jsx.d.ts

@@ -23,12 +23,12 @@ declare namespace astroHTML.JSX {
 		children?: Children;
 	}
 
-	type AstroBuiltinProps = import('./dist/@types/astro').AstroBuiltinProps;
-	type AstroBuiltinAttributes = import('./dist/@types/astro').AstroBuiltinAttributes;
-	type AstroDefineVarsAttribute = import('./dist/@types/astro').AstroDefineVarsAttribute;
-	type AstroScriptAttributes = import('./dist/@types/astro').AstroScriptAttributes &
+	type AstroBuiltinProps = import('./dist/@types/astro.js').AstroBuiltinProps;
+	type AstroBuiltinAttributes = import('./dist/@types/astro.js').AstroBuiltinAttributes;
+	type AstroDefineVarsAttribute = import('./dist/@types/astro.js').AstroDefineVarsAttribute;
+	type AstroScriptAttributes = import('./dist/@types/astro.js').AstroScriptAttributes &
 		AstroDefineVarsAttribute;
-	type AstroStyleAttributes = import('./dist/@types/astro').AstroStyleAttributes &
+	type AstroStyleAttributes = import('./dist/@types/astro.js').AstroStyleAttributes &
 		AstroDefineVarsAttribute;
 
 	// This is an unfortunate use of `any`, but unfortunately we can't make a type that works for every framework
@@ -1288,7 +1288,7 @@ declare namespace astroHTML.JSX {
 		zoomAndPan?: string | undefined | null;
 	}
 
-	interface IntrinsicElements {
+	interface DefinedIntrinsicElements {
 		// HTML
 		a: AnchorHTMLAttributes;
 		abbr: HTMLAttributes;
@@ -1461,7 +1461,9 @@ declare namespace astroHTML.JSX {
 		tspan: SVGAttributes;
 		use: SVGAttributes;
 		view: SVGAttributes;
+	}
 
+	interface IntrinsicElements extends DefinedIntrinsicElements {
 		// Allow for arbitrary elements
 		[name: string]: { [name: string]: any };
 	}

package/config.d.ts

@@ -1,5 +1,5 @@
 type ViteUserConfig = import('vite').UserConfig;
-type AstroUserConfig = import('./dist/@types/astro').AstroUserConfig;
+type AstroUserConfig = import('./dist/@types/astro.js').AstroUserConfig;
 
 /**
  * See the full Astro Configuration API Documentation

package/dist/core/add/index.js

@@ -475,7 +475,7 @@ async function getInstallIntegrationsCommand({
     case "yarn":
       return { pm: "yarn", command: "add", flags: [], dependencies };
     case "pnpm":
-      return { pm: "pnpm", command: "install", flags: [], dependencies };
+      return { pm: "pnpm", command: "add", flags: [], dependencies };
     default:
       return null;
   }

package/dist/core/app/index.js

@@ -20,14 +20,18 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _manifest, _manifestData, _routeDataToRouteInfo, _routeCache, _encoder, _logging, _streaming, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
+var _env, _manifest, _manifestData, _routeDataToRouteInfo, _encoder, _logging, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
 import mime from "mime";
-import { getSetCookiesFromResponse } from "../cookies/index.js";
+import { attachToResponse, getSetCookiesFromResponse } from "../cookies/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
 import { consoleLogDestination } from "../logger/console.js";
 import { error } from "../logger/core.js";
 import { joinPaths, prependForwardSlash } from "../path.js";
-import { render } from "../render/core.js";
+import {
+  createEnvironment,
+  createRenderContext,
+  renderPage
+} from "../render/index.js";
 import { RouteCache } from "../render/route-cache.js";
 import {
   createLinkStylesheetElementSet,
@@ -41,23 +45,46 @@ class App {
   constructor(manifest, streaming = true) {
     __privateAdd(this, _renderPage);
     __privateAdd(this, _callEndpoint);
+    __privateAdd(this, _env, void 0);
     __privateAdd(this, _manifest, void 0);
     __privateAdd(this, _manifestData, void 0);
     __privateAdd(this, _routeDataToRouteInfo, void 0);
-    __privateAdd(this, _routeCache, void 0);
     __privateAdd(this, _encoder, new TextEncoder());
     __privateAdd(this, _logging, {
       dest: consoleLogDestination,
       level: "info"
     });
-    __privateAdd(this, _streaming, void 0);
     __privateSet(this, _manifest, manifest);
     __privateSet(this, _manifestData, {
       routes: manifest.routes.map((route) => route.routeData)
     });
     __privateSet(this, _routeDataToRouteInfo, new Map(manifest.routes.map((route) => [route.routeData, route])));
-    __privateSet(this, _routeCache, new RouteCache(__privateGet(this, _logging)));
-    __privateSet(this, _streaming, streaming);
+    __privateSet(this, _env, createEnvironment({
+      adapterName: manifest.adapterName,
+      logging: __privateGet(this, _logging),
+      markdown: manifest.markdown,
+      mode: "production",
+      renderers: manifest.renderers,
+      async resolve(specifier) {
+        if (!(specifier in manifest.entryModules)) {
+          throw new Error(`Unable to resolve [${specifier}]`);
+        }
+        const bundlePath = manifest.entryModules[specifier];
+        switch (true) {
+          case bundlePath.startsWith("data:"):
+          case bundlePath.length === 0: {
+            return bundlePath;
+          }
+          default: {
+            return prependForwardSlash(joinPaths(manifest.base, bundlePath));
+          }
+        }
+      },
+      routeCache: new RouteCache(__privateGet(this, _logging)),
+      site: __privateGet(this, _manifest).site,
+      ssr: true,
+      streaming
+    }));
   }
   match(request, { matchNotFound = false } = {}) {
     const url = new URL(request.url);
@@ -116,13 +143,12 @@ class App {
     return getSetCookiesFromResponse(response);
   }
 }
+_env = new WeakMap();
 _manifest = new WeakMap();
 _manifestData = new WeakMap();
 _routeDataToRouteInfo = new WeakMap();
-_routeCache = new WeakMap();
 _encoder = new WeakMap();
 _logging = new WeakMap();
-_streaming = new WeakMap();
 _renderPage = new WeakSet();
 renderPage_fn = async function(request, routeData, mod, status = 200) {
   const url = new URL(request.url);
@@ -144,40 +170,16 @@ renderPage_fn = async function(request, routeData, mod, status = 200) {
     }
   }
   try {
-    const response = await render({
-      adapterName: manifest.adapterName,
-      links,
-      logging: __privateGet(this, _logging),
-      markdown: manifest.markdown,
-      mod,
-      mode: "production",
+    const ctx = createRenderContext({
+      request,
       origin: url.origin,
       pathname: url.pathname,
       scripts,
-      renderers,
-      async resolve(specifier) {
-        if (!(specifier in manifest.entryModules)) {
-          throw new Error(`Unable to resolve [${specifier}]`);
-        }
-        const bundlePath = manifest.entryModules[specifier];
-        switch (true) {
-          case bundlePath.startsWith("data:"):
-          case bundlePath.length === 0: {
-            return bundlePath;
-          }
-          default: {
-            return prependForwardSlash(joinPaths(manifest.base, bundlePath));
-          }
-        }
-      },
+      links,
       route: routeData,
-      routeCache: __privateGet(this, _routeCache),
-      site: __privateGet(this, _manifest).site,
-      ssr: true,
-      request,
-      streaming: __privateGet(this, _streaming),
       status
     });
+    const response = await renderPage(mod, ctx, __privateGet(this, _env));
     return response;
   } catch (err) {
     error(__privateGet(this, _logging), "ssr", err.stack || err.message || String(err));
@@ -191,16 +193,14 @@ _callEndpoint = new WeakSet();
 callEndpoint_fn = async function(request, routeData, mod, status = 200) {
   const url = new URL(request.url);
   const handler = mod;
-  const result = await callEndpoint(handler, {
-    logging: __privateGet(this, _logging),
+  const ctx = createRenderContext({
+    request,
     origin: url.origin,
     pathname: url.pathname,
-    request,
     route: routeData,
-    routeCache: __privateGet(this, _routeCache),
-    ssr: true,
     status
   });
+  const result = await callEndpoint(handler, __privateGet(this, _env), ctx);
   if (result.type === "response") {
     if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
       const fourOhFourRequest = new Request(new URL("/404", request.url));
@@ -221,10 +221,12 @@ callEndpoint_fn = async function(request, routeData, mod, status = 200) {
     }
     const bytes = __privateGet(this, _encoder).encode(body);
     headers.set("Content-Length", bytes.byteLength.toString());
-    return new Response(bytes, {
+    const response = new Response(bytes, {
       status: 200,
       headers
     });
+    attachToResponse(response, result.cookies);
+    return response;
   }
 };
 export {

package/dist/core/build/generate.js

@@ -13,7 +13,7 @@ import { runHookBuildGenerated } from "../../integrations/index.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
 import { debug, info } from "../logger/core.js";
-import { render } from "../render/core.js";
+import { createEnvironment, createRenderContext, renderPage } from "../render/index.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
 import { createLinkStylesheetElementSet, createModuleScriptsSet } from "../render/ssr-element.js";
 import { createRequest } from "../request.js";
@@ -234,19 +234,14 @@ async function generatePath(pathname, opts, gopts) {
     opts.settings.config.build.format,
     pageData.route.type
   );
-  const options = {
+  const env = createEnvironment({
     adapterName: void 0,
-    links,
     logging,
     markdown: {
       ...settings.config.markdown,
       isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
     },
-    mod,
     mode: opts.mode,
-    origin,
-    pathname,
-    scripts,
     renderers,
     async resolve(specifier) {
       const hashedFilePath = internals.entrySpecifierToBundleMap.get(specifier);
@@ -258,24 +253,31 @@ async function generatePath(pathname, opts, gopts) {
       }
       return prependForwardSlash(npath.posix.join(settings.config.base, hashedFilePath));
     },
-    request: createRequest({ url, headers: new Headers(), logging, ssr }),
-    route: pageData.route,
     routeCache,
     site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
     ssr,
     streaming: true
-  };
+  });
+  const ctx = createRenderContext({
+    origin,
+    pathname,
+    request: createRequest({ url, headers: new Headers(), logging, ssr }),
+    scripts,
+    links,
+    route: pageData.route
+  });
   let body;
   let encoding;
   if (pageData.route.type === "endpoint") {
-    const result = await callEndpoint(mod, options);
+    const endpointHandler = mod;
+    const result = await callEndpoint(endpointHandler, env, ctx);
     if (result.type === "response") {
       throw new Error(`Returning a Response from an endpoint is not supported in SSG mode.`);
     }
     body = result.body;
     encoding = result.encoding;
   } else {
-    const response = await render(options);
+    const response = await renderPage(mod, ctx, env);
     if (response.status !== 200 || !response.body) {
       return;
     }

package/dist/core/config/schema.js

@@ -137,7 +137,18 @@ function createRelativeSchema(cmd, fileProtocolRoot) {
       serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry)
     }).optional().default({}),
     server: z.preprocess(
-      (val) => typeof val === "function" ? val({ command: cmd === "dev" ? "dev" : "preview" }) : val,
+      (val) => {
+        if (typeof val === "function") {
+          const result = val({ command: cmd === "dev" ? "dev" : "preview" });
+          if (val.port)
+            result.port = val.port;
+          if (val.host)
+            result.host = val.host;
+          return result;
+        } else {
+          return val;
+        }
+      },
       z.object({
         host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
         port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),

package/dist/core/config/tsconfig.js

@@ -44,24 +44,23 @@ function loadTSConfig(cwd, resolve = true) {
   cwd = cwd ?? process.cwd();
   let config = tsr.tsconfigResolverSync({
     cwd,
-    filePath: resolve ? void 0 : cwd
+    filePath: resolve ? void 0 : cwd,
+    ignoreExtends: !resolve
   });
   if (!resolve && config.reason === "invalid-config" && !existsSync(join(cwd, "tsconfig.json"))) {
     config = { reason: "not-found", path: void 0, exists: false };
-  } else {
-    return config;
   }
   if (config.reason === "not-found") {
     const jsconfig = tsr.tsconfigResolverSync({
       cwd,
       filePath: resolve ? void 0 : cwd,
-      searchName: "jsconfig.json"
+      searchName: "jsconfig.json",
+      ignoreExtends: !resolve
     });
     if (!resolve && jsconfig.reason === "invalid-config" && !existsSync(join(cwd, "jsconfig.json"))) {
       return { reason: "not-found", path: void 0, exists: false };
-    } else {
-      return jsconfig;
     }
+    return jsconfig;
   }
   return config;
 }

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.5.0";
+const ASTRO_VERSION = "1.5.1";
 export {
   ASTRO_VERSION
 };

package/dist/core/dev/index.js

@@ -54,7 +54,7 @@ async function dev(settings, options) {
       isRestart
     })
   );
-  const currentVersion = "1.5.0";
+  const currentVersion = "1.5.1";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

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

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import type { SSROptions } from '../../render/dev';
-export declare function call(ssrOpts: SSROptions): Promise<{
+export declare function call(options: SSROptions): Promise<{
     type: "simple";
     body: string;
     encoding?: BufferEncoding | undefined;
+    cookies: import("../../cookies/cookies").AstroCookies;
 } | {
     type: "response";
     response: Response;

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

@@ -1,14 +1,18 @@
-import { preload } from "../../render/dev/index.js";
+import { createRenderContext } from "../../render/index.js";
 import { call as callEndpoint } from "../index.js";
-async function call(ssrOpts) {
-  var _a;
-  const [, mod] = await preload(ssrOpts);
-  return await callEndpoint(mod, {
-    ...ssrOpts,
-    ssr: ssrOpts.settings.config.output === "server",
-    site: ssrOpts.settings.config.site,
-    adapterName: (_a = ssrOpts.settings.config.adapter) == null ? void 0 : _a.name
+async function call(options) {
+  const {
+    env,
+    preload: [, mod]
+  } = options;
+  const endpointHandler = mod;
+  const ctx = createRenderContext({
+    request: options.request,
+    origin: options.origin,
+    pathname: options.pathname,
+    route: options.route
   });
+  return await callEndpoint(endpointHandler, env, ctx);
 }
 export {
   call

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

@@ -1,14 +1,15 @@
 /// <reference types="node" />
 import type { EndpointHandler } from '../../@types/astro';
-import type { RenderOptions } from '../render/core';
-export declare type EndpointOptions = Pick<RenderOptions, 'logging' | 'origin' | 'request' | 'route' | 'routeCache' | 'pathname' | 'route' | 'site' | 'ssr' | 'status' | 'adapterName'>;
+import type { Environment, RenderContext } from '../render/index';
+import { AstroCookies } from '../cookies/index.js';
 declare type EndpointCallResult = {
     type: 'simple';
     body: string;
     encoding?: BufferEncoding;
+    cookies: AstroCookies;
 } | {
     type: 'response';
     response: Response;
 };
-export declare function call(mod: EndpointHandler, opts: EndpointOptions): Promise<EndpointCallResult>;
+export declare function call(mod: EndpointHandler, env: Environment, ctx: RenderContext): Promise<EndpointCallResult>;
 export {};

package/dist/core/endpoint/index.js

@@ -42,22 +42,29 @@ function createAPIContext({
     }
   };
 }
-async function call(mod, opts) {
-  const paramsAndPropsResp = await getParamsAndProps({ ...opts, mod });
+async function call(mod, env, ctx) {
+  const paramsAndPropsResp = await getParamsAndProps({
+    mod,
+    route: ctx.route,
+    routeCache: env.routeCache,
+    pathname: ctx.pathname,
+    logging: env.logging,
+    ssr: env.ssr
+  });
   if (paramsAndPropsResp === GetParamsAndPropsError.NoMatchingStaticPath) {
     throw new Error(
-      `[getStaticPath] route pattern matched, but no matching static path found. (${opts.pathname})`
+      `[getStaticPath] route pattern matched, but no matching static path found. (${ctx.pathname})`
     );
   }
   const [params, props] = paramsAndPropsResp;
   const context = createAPIContext({
-    request: opts.request,
+    request: ctx.request,
     params,
     props,
-    site: opts.site,
-    adapterName: opts.adapterName
+    site: env.site,
+    adapterName: env.adapterName
   });
-  const response = await renderEndpoint(mod, context, opts.ssr);
+  const response = await renderEndpoint(mod, context, env.ssr);
   if (response instanceof Response) {
     attachToResponse(response, context.cookies);
     return {
@@ -68,7 +75,8 @@ async function call(mod, opts) {
   return {
     type: "simple",
     body: response.body,
-    encoding: response.encoding
+    encoding: response.encoding,
+    cookies: context.cookies
   };
 }
 export {

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   site,
   isRestart = false
 }) {
-  const version = "1.5.0";
+  const version = "1.5.1";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -250,7 +250,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.5.0"}`
+        `v${"1.5.1"}`
       )} ${headline}`
     );
   }

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