astro 2.7.4 → 2.8.1

package/dist/@types/astro.d.ts

@@ -784,6 +784,26 @@ export interface AstroUserConfig {
          * ```
          */
         split?: boolean;
+        /**
+         * @docs
+         * @name build.excludeMiddleware
+         * @type {boolean}
+         * @default {false}
+         * @version 2.8.0
+         * @description
+         * Defines whether or not any SSR middleware code will be bundled when built.
+         *
+         * When enabled, middleware code is not bundled and imported by all pages during the build. To instead execute and import middleware code manually, set `build.excludeMiddleware: true`:
+         *
+         * ```js
+         * {
+         *   build: {
+         *     excludeMiddleware: true
+         *   }
+         * }
+         * ```
+         */
+        excludeMiddleware?: boolean;
     };
     /**
      * @docs
@@ -1665,6 +1685,10 @@ export interface AstroIntegration {
              * the physical file you should import.
              */
             entryPoints: Map<RouteData, URL>;
+            /**
+             * File path of the emitted middleware
+             */
+            middlewareEntryPoint: URL | undefined;
         }) => void | Promise<void>;
         'astro:build:start'?: () => void | Promise<void>;
         'astro:build:setup'?: (options: {
@@ -1737,15 +1761,6 @@ export interface SSRElement {
     props: Record<string, any>;
     children: string;
 }
-export interface SSRMetadata {
-    renderers: SSRLoadedRenderer[];
-    pathname: string;
-    hasHydrationScript: boolean;
-    hasDirectives: Set<string>;
-    hasRenderedHead: boolean;
-    headInTree: boolean;
-    clientDirectives: Map<string, string>;
-}
 /**
  * A hint on whether the Astro runtime needs to wait on a component to render head
  * content. The meanings:
@@ -1766,15 +1781,34 @@ export interface SSRResult {
     scripts: Set<SSRElement>;
     links: Set<SSRElement>;
     componentMetadata: Map<string, SSRComponentMetadata>;
-    propagators: Map<AstroComponentFactory, AstroComponentInstance>;
-    extraHead: Array<string>;
-    cookies: AstroCookies | undefined;
     createAstro(Astro: AstroGlobalPartial, props: Record<string, any>, slots: Record<string, any> | null): AstroGlobal;
     resolve: (s: string) => Promise<string>;
     response: ResponseInit;
-    scope: number;
+    renderers: SSRLoadedRenderer[];
+    /**
+     * Map of directive name (e.g. `load`) to the directive script code
+     */
+    clientDirectives: Map<string, string>;
+    compressHTML: boolean;
+    /**
+     * Only used for logging
+     */
+    pathname: string;
+    cookies: AstroCookies | undefined;
     _metadata: SSRMetadata;
 }
+/**
+ * Ephemeral and mutable state during rendering that doesn't rely
+ * on external configuration
+ */
+export interface SSRMetadata {
+    hasHydrationScript: boolean;
+    hasDirectives: Set<string>;
+    hasRenderedHead: boolean;
+    headInTree: boolean;
+    extraHead: string[];
+    propagators: Map<AstroComponentFactory, AstroComponentInstance>;
+}
 export interface PreviewServer {
     host?: string;
     port: number;

package/dist/{core → cli}/add/index.d.ts

@@ -1,15 +1,16 @@
 import type yargs from 'yargs-parser';
-import { type LogOptions } from '../logger/core.js';
-export interface AddOptions {
+import { type LogOptions } from '../../core/logger/core.js';
+interface AddOptions {
     logging: LogOptions;
     flags: yargs.Arguments;
     cwd?: string;
 }
-export interface IntegrationInfo {
+interface IntegrationInfo {
     id: string;
     packageName: string;
     dependencies: [name: string, version: string][];
     type: 'integration' | 'adapter';
 }
-export default function add(names: string[], { cwd, flags, logging }: AddOptions): Promise<void>;
+export declare function add(names: string[], { cwd, flags, logging }: AddOptions): Promise<void>;
 export declare function validateIntegrations(integrations: string[]): Promise<IntegrationInfo[]>;
+export {};

package/dist/{core → cli}/add/index.js

@@ -8,18 +8,18 @@ import path from "path";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import { fileURLToPath, pathToFileURL } from "url";
-import { loadTSConfig, resolveConfigPath } from "../config/index.js";
+import { loadTSConfig, resolveConfigPath } from "../../core/config/index.js";
 import {
   defaultTSConfig,
   presets,
   updateTSConfigForFramework
-} from "../config/tsconfig.js";
-import { debug, info } from "../logger/core.js";
-import * as msg from "../messages.js";
-import { printHelp } from "../messages.js";
-import { appendForwardSlash } from "../path.js";
-import { apply as applyPolyfill } from "../polyfill.js";
-import { parseNpmName } from "../util.js";
+} from "../../core/config/tsconfig.js";
+import { debug, info } from "../../core/logger/core.js";
+import * as msg from "../../core/messages.js";
+import { printHelp } from "../../core/messages.js";
+import { appendForwardSlash } from "../../core/path.js";
+import { apply as applyPolyfill } from "../../core/polyfill.js";
+import { parseNpmName } from "../../core/util.js";
 import { generate, parse, t, visit } from "./babel.js";
 import { ensureImport } from "./imports.js";
 import { wrapDefaultExport } from "./wrapper.js";
@@ -637,7 +637,8 @@ async function validateIntegrations(integrations) {
           const meta = pkgJson["peerDependenciesMeta"] || {};
           for (const peer in pkgJson["peerDependencies"]) {
             const optional = ((_a = meta[peer]) == null ? void 0 : _a.optional) || false;
-            if (!optional) {
+            const isAstro = peer === "astro";
+            if (!optional && !isAstro) {
               dependencies.push([peer, pkgJson["peerDependencies"][peer]]);
             }
           }
@@ -824,6 +825,6 @@ async function setupIntegrationConfig(opts) {
   }
 }
 export {
-  add as default,
+  add,
   validateIntegrations
 };

package/dist/cli/docs/index.d.ts

@@ -0,0 +1,6 @@
+import type yargs from 'yargs-parser';
+interface DocsOptions {
+    flags: yargs.Arguments;
+}
+export declare function docs({ flags }: DocsOptions): Promise<import("execa").ExecaReturnValue<string> | undefined>;
+export {};

package/dist/cli/docs/index.js

@@ -0,0 +1,18 @@
+import { printHelp } from "../../core/messages.js";
+import { openInBrowser } from "./open.js";
+async function docs({ flags }) {
+  if (flags.help || flags.h) {
+    printHelp({
+      commandName: "astro docs",
+      tables: {
+        Flags: [["--help (-h)", "See all available flags."]]
+      },
+      description: `Launches the Astro Docs website directly from the terminal.`
+    });
+    return;
+  }
+  return await openInBrowser("https://docs.astro.build/");
+}
+export {
+  docs
+};

package/dist/cli/index.js

@@ -16,7 +16,6 @@ import { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js
 import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
 import * as event from "../events/index.js";
 import { eventConfigError, eventError, telemetry } from "../events/index.js";
-import { openInBrowser } from "./open.js";
 function printAstroHelp() {
   printHelp({
     commandName: "astro",
@@ -29,6 +28,7 @@ function printAstroHelp() {
         ["check", "Check your project for errors."],
         ["dev", "Start the development server."],
         ["docs", "Open documentation in your web browser."],
+        ["info", "List info about your current Astro setup."],
         ["preview", "Preview your build locally."],
         ["sync", "Generate content collection types."],
         ["telemetry", "Configure telemetry settings."]
@@ -46,7 +46,7 @@ function printAstroHelp() {
     }
   });
 }
-async function printVersion() {
+function printVersion() {
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${ASTRO_VERSION}`)}`);
 }
@@ -62,7 +62,8 @@ function resolveCommand(flags) {
     "build",
     "preview",
     "check",
-    "docs"
+    "docs",
+    "info"
   ]);
   if (supportedCommands.has(cmd)) {
     return cmd;
@@ -89,12 +90,29 @@ async function runCommand(cmd, flags) {
   switch (cmd) {
     case "help":
       printAstroHelp();
-      return process.exit(0);
+      return;
     case "version":
-      await printVersion();
-      return process.exit(0);
+      printVersion();
+      return;
+    case "info": {
+      const { printInfo } = await import("./info/index.js");
+      await printInfo({ cwd: root, flags });
+      return;
+    }
+    case "docs": {
+      telemetry.record(event.eventCliSession(cmd));
+      const { docs } = await import("./docs/index.js");
+      await docs({ flags });
+      return;
+    }
+    case "telemetry": {
+      const { update } = await import("./telemetry/index.js");
+      const subcommand = (_a = flags._[3]) == null ? void 0 : _a.toString();
+      await update(subcommand, { flags });
+      return;
+    }
   }
-  let logging = {
+  const logging = {
     dest: nodeLogDestination,
     level: "info"
   };
@@ -106,29 +124,11 @@ async function runCommand(cmd, flags) {
   }
   switch (cmd) {
     case "add": {
-      const { default: add } = await import("../core/add/index.js");
       telemetry.record(event.eventCliSession(cmd));
+      const { add } = await import("./add/index.js");
       const packages = flags._.slice(3);
-      return await add(packages, { cwd: root, flags, logging });
-    }
-    case "docs": {
-      telemetry.record(event.eventCliSession(cmd));
-      if (flags.help || flags.h) {
-        printHelp({
-          commandName: "astro docs",
-          tables: {
-            Flags: [["--help (-h)", "See all available flags."]]
-          },
-          description: `Launches the Astro Docs website directly from the terminal.`
-        });
-        return;
-      }
-      return await openInBrowser("https://docs.astro.build/");
-    }
-    case "telemetry": {
-      const telemetryHandler = await import("./telemetry.js");
-      const subcommand = (_a = flags._[3]) == null ? void 0 : _a.toString();
-      return await telemetryHandler.update(subcommand, { flags });
+      await add(packages, { cwd: root, flags, logging });
+      return;
     }
   }
   if (!process.env.NODE_ENV) {
@@ -137,8 +137,7 @@ async function runCommand(cmd, flags) {
   let { astroConfig: initialAstroConfig, userConfig: initialUserConfig } = await openConfig({
     cwd: root,
     flags,
-    cmd,
-    logging
+    cmd
   }).catch(async (e) => {
     await handleConfigError(e, { cmd, cwd: root, flags, logging });
     return {};

package/dist/cli/info/index.d.ts

@@ -0,0 +1,7 @@
+import type yargs from 'yargs-parser';
+interface InfoOptions {
+    cwd?: string;
+    flags: yargs.Arguments;
+}
+export declare function printInfo({ cwd, flags }: InfoOptions): Promise<void>;
+export {};

package/dist/cli/info/index.js

@@ -0,0 +1,45 @@
+import * as colors from "kleur/colors";
+import { arch, platform } from "node:os";
+import whichPm from "which-pm";
+import { openConfig } from "../../core/config/index.js";
+import { ASTRO_VERSION } from "../../core/constants.js";
+async function printInfo({ cwd, flags }) {
+  var _a;
+  const packageManager = await whichPm(process.cwd());
+  let adapter = "Couldn't determine.";
+  let integrations = [];
+  const MAX_PADDING = 25;
+  function printRow(label, value) {
+    const padding = MAX_PADDING - label.length;
+    console.log(`${colors.bold(label)}` + " ".repeat(padding) + `${colors.green(value)}`);
+  }
+  try {
+    const { userConfig } = await openConfig({
+      cwd,
+      flags,
+      cmd: "info"
+    });
+    if ((_a = userConfig.adapter) == null ? void 0 : _a.name) {
+      adapter = userConfig.adapter.name;
+    }
+    if (userConfig.integrations) {
+      integrations = ((userConfig == null ? void 0 : userConfig.integrations) ?? []).filter(Boolean).flat().map((i) => i == null ? void 0 : i.name);
+    }
+  } catch (_e) {
+  }
+  console.log();
+  const packageManagerName = (packageManager == null ? void 0 : packageManager.name) ?? "Couldn't determine.";
+  printRow("Astro version", `v${ASTRO_VERSION}`);
+  printRow("Package manager", packageManagerName);
+  printRow("Platform", platform());
+  printRow("Architecture", arch());
+  printRow("Adapter", adapter);
+  let integrationsString = "None or couldn't determine.";
+  if (integrations.length > 0) {
+    integrationsString = integrations.join(", ");
+  }
+  printRow("Integrations", integrationsString);
+}
+export {
+  printInfo
+};

package/dist/cli/{telemetry.d.ts → telemetry/index.d.ts}

@@ -1,5 +1,6 @@
 import type yargs from 'yargs-parser';
-export interface TelemetryOptions {
+interface TelemetryOptions {
     flags: yargs.Arguments;
 }
 export declare function update(subcommand: string, { flags }: TelemetryOptions): Promise<void>;
+export {};

package/dist/cli/{telemetry.js → telemetry/index.js}

@@ -1,5 +1,5 @@
-import * as msg from "../core/messages.js";
-import { telemetry } from "../events/index.js";
+import * as msg from "../../core/messages.js";
+import { telemetry } from "../../events/index.js";
 async function update(subcommand, { flags }) {
   const isValid = ["enable", "disable", "reset"].includes(subcommand);
   if (flags.help || flags.h || !isValid) {

package/dist/config/index.js

@@ -25,10 +25,7 @@ function getViteConfig(inlineConfig) {
       dest: nodeLogDestination,
       level: "info"
     };
-    const { astroConfig: config } = await openConfig({
-      cmd,
-      logging
-    });
+    const { astroConfig: config } = await openConfig({ cmd });
     const settings = createSettings(config, inlineConfig.root);
     await runHookConfigSetup({ settings, command: cmd, logging });
     const viteConfig = await createVite(

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -168,8 +168,8 @@ function globWithUnderscoresIgnored(relContentDir, exts) {
   const contentDir = appendForwardSlash(relContentDir);
   return [
     `${contentDir}**/*${extGlob}`,
-    `!${contentDir}_*/**${extGlob}`,
-    `!${contentDir}_*${extGlob}`
+    `!${contentDir}**/_*/**${extGlob}`,
+    `!${contentDir}**/_*${extGlob}`
   ];
 }
 export {

package/dist/core/app/index.js

@@ -44,6 +44,7 @@ class App {
       logging: this.#logging,
       markdown: manifest.markdown,
       mode: "production",
+      compressHTML: manifest.compressHTML,
       renderers: manifest.renderers,
       clientDirectives: manifest.clientDirectives,
       async resolve(specifier) {
@@ -170,7 +171,6 @@ class App {
     const url = new URL(request.url);
     const pathname = prependForwardSlash(this.removeBase(url.pathname));
     const info = this.#routeDataToRouteInfo.get(routeData);
-    const isCompressHTML = this.#manifest.compressHTML ?? false;
     const links = /* @__PURE__ */ new Set();
     const styles = createStylesheetElementSet(info.styles);
     let scripts = /* @__PURE__ */ new Set();
@@ -190,7 +190,6 @@ class App {
       const mod = await page.page();
       const renderContext = await createRenderContext({
         request,
-        origin: url.origin,
         pathname,
         componentMetadata: this.#manifest.componentMetadata,
         scripts,
@@ -219,8 +218,7 @@ class App {
               mod,
               renderContext,
               env: this.#env,
-              cookies: apiContext.cookies,
-              isCompressHTML
+              cookies: apiContext.cookies
             });
           }
         );
@@ -229,8 +227,7 @@ class App {
           mod,
           renderContext,
           env: this.#env,
-          cookies: apiContext.cookies,
-          isCompressHTML
+          cookies: apiContext.cookies
         });
       }
       Reflect.set(request, responseSentSymbol, true);
@@ -250,14 +247,13 @@ class App {
     const handler = mod;
     const ctx = await createRenderContext({
       request,
-      origin: url.origin,
       pathname,
       route: routeData,
       status,
       env: this.#env,
       mod: handler
     });
-    const result = await callEndpoint(handler, this.#env, ctx, this.#logging, page.onRequest);
+    const result = await callEndpoint(handler, this.#env, ctx, page.onRequest);
     if (result.type === "response") {
       if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
         const fourOhFourRequest = new Request(new URL("/404", request.url));

package/dist/core/app/types.d.ts

@@ -30,8 +30,8 @@ export type SSRManifest = {
     adapterName: string;
     routes: RouteInfo[];
     site?: string;
-    base?: string;
-    compressHTML?: boolean;
+    base: string;
+    compressHTML: boolean;
     assetsPrefix?: string;
     markdown: MarkdownRenderingOptions;
     renderers: SSRLoadedRenderer[];

package/dist/core/build/generate.d.ts

@@ -1,7 +1,15 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { AstroSettings } from '../../@types/astro';
+import type { AstroSettings, SSRLoadedRenderer, SSRManifest } from '../../@types/astro';
 import { type BuildInternals } from '../../core/build/internal.js';
 import type { StaticBuildOptions } from './types';
 export declare function rootRelativeFacadeId(facadeId: string, settings: AstroSettings): string;
 export declare function chunkIsPage(settings: AstroSettings, output: OutputAsset | OutputChunk, internals: BuildInternals): boolean;
 export declare function generatePages(opts: StaticBuildOptions, internals: BuildInternals): Promise<void>;
+/**
+ * It creates a `SSRManifest` from the `AstroSettings`.
+ *
+ * Renderers needs to be pulled out from the page module emitted during the build.
+ * @param settings
+ * @param renderers
+ */
+export declare function generateRuntimeManifest(settings: AstroSettings, internals: BuildInternals, renderers: SSRLoadedRenderer[]): SSRManifest;