astro 7.1.6 → 7.2.0

package/dist/core/session/config.js

@@ -3,7 +3,7 @@ const SessionDriverConfigSchema = z.object({
   config: z.record(z.string(), z.any()).optional(),
   entrypoint: z.union([z.string(), z.instanceof(URL)])
 });
-const SessionSchema = z.object({
+const SessionObjectSchema = z.object({
   driver: z.union([
     z.string().superRefine(() => {
       console.warn(
@@ -26,6 +26,7 @@ const SessionSchema = z.object({
   ]).optional(),
   ttl: z.number().optional()
 });
+const SessionSchema = z.union([z.literal(false), SessionObjectSchema]);
 export {
   SessionDriverConfigSchema,
   SessionSchema

package/dist/core/session/provider-disabled.d.ts

@@ -0,0 +1,2 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+export declare function provideSession(state: FetchState): void;

package/dist/core/session/provider-disabled.js

@@ -0,0 +1,7 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+function provideSession(state) {
+  state.pipeline.usedFeatures |= PipelineFeatures.sessions;
+}
+export {
+  provideSession
+};

package/dist/core/session/provider.d.ts

@@ -0,0 +1 @@
+export { provideSession } from './handler.js';

package/dist/core/session/provider.js

@@ -0,0 +1,4 @@
+import { provideSession } from "./handler.js";
+export {
+  provideSession
+};

package/dist/core/session/utils.js

@@ -31,6 +31,9 @@ function normalizeSessionDriverConfig(driver, options) {
   };
 }
 function sessionConfigToManifest(config) {
+  if (config === false) {
+    return void 0;
+  }
   const sessionDriver = config?.driver;
   if (!config || !sessionDriver) {
     return void 0;

package/dist/core/session/vite-plugin.d.ts

@@ -4,3 +4,6 @@ export declare const VIRTUAL_SESSION_DRIVER_ID = "virtual:astro:session-driver";
 export declare function vitePluginSessionDriver({ settings }: {
     settings: AstroSettings;
 }): VitePlugin;
+export declare function vitePluginSessionProvider({ settings }: {
+    settings: AstroSettings;
+}): VitePlugin;

package/dist/core/session/vite-plugin.js

@@ -1,6 +1,8 @@
+import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { SessionStorageInitError } from "../errors/errors-data.js";
 import { AstroError } from "../errors/index.js";
+import { normalizePath } from "../viteUtils.js";
 import { normalizeSessionDriverConfig } from "./utils.js";
 const VIRTUAL_SESSION_DRIVER_ID = "virtual:astro:session-driver";
 const RESOLVED_VIRTUAL_SESSION_DRIVER_ID = "\0" + VIRTUAL_SESSION_DRIVER_ID;
@@ -21,13 +23,11 @@ function vitePluginSessionDriver({ settings }) {
         id: new RegExp(`^${RESOLVED_VIRTUAL_SESSION_DRIVER_ID}$`)
       },
       async handler() {
-        if (!settings.config.session?.driver) {
+        const session = settings.config.session;
+        if (session === false || !session?.driver) {
           return { code: "export default null;" };
         }
-        const driver = normalizeSessionDriverConfig(
-          settings.config.session.driver,
-          settings.config.session.options
-        );
+        const driver = normalizeSessionDriverConfig(session.driver, session.options);
         const importerPath = fileURLToPath(import.meta.url);
         const resolved = await this.resolve(driver.entrypoint, importerPath);
         if (!resolved) {
@@ -48,7 +48,42 @@ export default _default;`
     }
   };
 }
+const PROVIDER_FILENAME = "provider.js";
+const DISABLED_PROVIDER_FILENAME = "provider-disabled.js";
+function canonicalizePath(filePath) {
+  try {
+    return normalizePath(realpathSync(filePath));
+  } catch {
+    return normalizePath(filePath);
+  }
+}
+function vitePluginSessionProvider({ settings }) {
+  const providerPath = canonicalizePath(
+    fileURLToPath(new URL(`./${PROVIDER_FILENAME}`, import.meta.url))
+  );
+  const disabledProviderPath = canonicalizePath(
+    fileURLToPath(new URL(`./${DISABLED_PROVIDER_FILENAME}`, import.meta.url))
+  );
+  return {
+    name: "astro:session-provider",
+    enforce: "pre",
+    async resolveId(id, importer) {
+      const session = settings.config.session;
+      const hasSessionDriver = session !== false && !!session?.driver;
+      if (hasSessionDriver) return null;
+      if (!normalizePath(id).endsWith(`/session/${PROVIDER_FILENAME}`)) return null;
+      if (canonicalizePath(id) === providerPath) return disabledProviderPath;
+      if (!importer) return null;
+      const resolved = await this.resolve(id, importer, { skipSelf: true });
+      if (resolved && canonicalizePath(resolved.id) === providerPath) {
+        return disabledProviderPath;
+      }
+      return null;
+    }
+  };
+}
 export {
   VIRTUAL_SESSION_DRIVER_ID,
-  vitePluginSessionDriver
+  vitePluginSessionDriver,
+  vitePluginSessionProvider
 };

package/dist/integrations/hooks.js

@@ -260,7 +260,9 @@ async function runHookConfigSetup({
     try {
       updatedConfig = await validateConfigRefined(updatedConfig);
       if (isLoggerUpdated) {
-        logger.setDestination(await loadLoggerDestination(updatedConfig.logger));
+        logger.setDestination(
+          await loadLoggerDestination(updatedConfig.logger, updatedConfig.root)
+        );
       }
     } catch (error) {
       integrationLogger.error("An error occurred while updating the config");

package/dist/runtime/prerender/static-paths.js

@@ -61,7 +61,11 @@ class StaticPaths {
     });
     for (const staticPath of staticPaths) {
       const pathname = stringifyParams(staticPath.params, route, manifest.trailingSlash);
-      paths.push({ pathname, route });
+      paths.push({
+        pathname,
+        route,
+        cacheKey: staticPath.cacheKey === void 0 ? void 0 : String(staticPath.cacheKey)
+      });
     }
     return paths;
   }

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

@@ -35,6 +35,9 @@ function isCustomElement(tagName) {
   return tagName.includes("-");
 }
 function handleBooleanAttribute(key, value, shouldEscape, tagName) {
+  if (key === "popover") {
+    return markHTMLString(value ? ` ${key}` : "");
+  }
   if (tagName && isCustomElement(tagName)) {
     return markHTMLString(` ${key}="${toAttributeString(value, shouldEscape)}"`);
   }

package/dist/types/public/common.d.ts

@@ -13,6 +13,7 @@ export interface GetStaticPathsOptions {
 export type GetStaticPathsItem = {
     params: Params;
     props?: Props;
+    cacheKey?: string | number;
 };
 export type GetStaticPathsResult = GetStaticPathsItem[];
 export type GetStaticPathsResultKeyed = GetStaticPathsResult & {

package/dist/types/public/config.d.ts

@@ -1171,6 +1171,7 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
          * Setting `build.format` controls what `Astro.url` is set to during the build. When it is:
          * - `directory` - The `Astro.url.pathname` will include a trailing slash to mimic folder behavior. (e.g. `/foo/`)
          * - `file` - The `Astro.url.pathname` will include `.html`. (e.g. `/foo.html`)
+         * - `preserve` - The `Astro.url.pathname` matches the generated file for each page: index pages include a trailing slash (e.g. `/foo/`), while non-index pages include `.html` (e.g. `/foo.html`).
          *
          * This means that when you create relative URLs using `new URL('./relative', Astro.url)`, you will get consistent behavior between dev and build.
          *
@@ -1535,7 +1536,8 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      * @description
      *
      * The entrypoint for the [logger implementation](https://docs.astro.build/en/reference/logger-reference/#the-logger-implementation).
-     * This can be an npm package, or a `URL` pointing to a file in your project:
+     * This can be an npm package, a path relative to your project root, or a `URL` pointing to a
+     * file in your project:
      *
      * ```js title="astro.config.mjs"
      * import { defineConfig } from 'astro/config';
@@ -1546,6 +1548,9 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      *   }
      * });
      * ```
+     *
+     * The logger entrypoint must be a JavaScript file. TypeScript is not supported. If Astro fails to load
+     *  the implementation, it falls back to its default logger.
      */
     /**
      * @docs
@@ -1573,6 +1578,7 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
     /**
      * @docs
      * @kind heading
+     * @type {object | false}
      * @version 5.7.0
      * @name Session Options
      * @description
@@ -1596,9 +1602,19 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      *
      * Session drivers are configured at build time. This means environment variables used in the driver configuration are inlined. You must create your own driver entrypoint to [override the configuration at runtime](https://docs.astro.build/en/guides/sessions/#overriding-the-configuration-at-runtime).
      *
+     * Since Astro v7.2.0, you can opt out of session support by setting the option to `false`. When sessions are disabled, the session runtime is excluded from the SSR bundle, and adapters skip wiring their default session driver. This is useful for serverless and edge runtimes where bundle parse time is sensitive.
+     *
+     * ```js title="astro.config.mjs"
+     * import { defineConfig } from 'astro/config';
+     *
+     * export default defineConfig({
+     *   session: false,
+     * });
+     * ```
+     *
      * See [the sessions guide](https://docs.astro.build/en/guides/sessions/) for more information.
      */
-    session?: SessionConfig<TDriver>;
+    session?: SessionConfig<TDriver> | false;
     /**
      * @docs
      * @name session.driver
@@ -3164,6 +3180,47 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
             /** Maximum UTF-8 byte size of each data store chunk. */
             chunkSize: number;
         };
+        /**
+         * @name experimental.incrementalBuild
+         * @type {boolean}
+         * @default `false`
+         * @version 7.2
+         * @description
+         *
+         * Enables incremental static builds. When enabled, pages with a `cacheKey` returned
+         * from `getStaticPaths()` can be skipped during subsequent builds if neither
+         * their data nor their dependencies have changed.
+         *
+         * On the first build, all pages are rendered normally and a cache manifest is saved.
+         * On subsequent builds, each page is checked against the manifest: if the page's
+         * `cacheKey` and the hash of its module dependency graph both match, the page is
+         * skipped and the previous output is preserved.
+         *
+         * ```js
+         * // astro.config.mjs
+         * {
+         *   experimental: {
+         *     incrementalBuild: true,
+         *   },
+         * }
+         * ```
+         *
+         * In your dynamic routes, return a `cacheKey` from `getStaticPaths()`:
+         *
+         * ```js
+         * // src/pages/blog/[slug].astro
+         * export async function getStaticPaths() {
+         *   const posts = await fetchPosts();
+         *   return posts.map(post => ({
+         *     params: { slug: post.slug },
+         *     props: { post },
+         *     cacheKey: post.digest,
+         *   }));
+         * }
+         * ```
+         * See the [experimental incremental static builds](https://docs.astro.build/en/reference/experimental-flags/incremental-build/) for more information.
+         */
+        incrementalBuild?: boolean;
     };
 }
 /**

package/dist/types/public/integrations.d.ts

@@ -1,7 +1,7 @@
 import type { AddressInfo } from 'node:net';
 import type { ViteDevServer, InlineConfig } from 'vite';
 import type { SerializedSSRManifest } from '../../core/app/types.js';
-import type { AssetsGlobalStaticImagesList } from '../../assets/types.js';
+import type { AssetsGlobalStaticImagesList, SerializedStaticImage } from '../../assets/types.js';
 import type { PageBuildData } from '../../core/build/types.js';
 import type { AstroIntegrationLogger } from '../../core/logger/core.js';
 import type { AdapterFeatureStability } from '../../integrations/features-validation.js';
@@ -194,6 +194,28 @@ export type AstroAdapter = {
 export interface PathWithRoute {
     pathname: string;
     route: RouteData;
+    cacheKey?: string;
+}
+/**
+ * Incremental-build data an out-of-process prerenderer collects while rendering
+ * a page, reported back to the build process so skipped pages can be tracked and
+ * replayed without a re-render.
+ */
+export interface PrerenderRenderMetadata {
+    /** Root-relative `filePath`s of the content entries the page rendered. */
+    contentEntryKeys?: string[];
+    /** Optimized-image transforms the page resolved. */
+    staticImages?: SerializedStaticImage[];
+}
+/**
+ * The richer result a prerenderer's `render()` may return instead of a bare
+ * `Response`, pairing the rendered response with the incremental-build metadata
+ * collected for that page. Used by out-of-process prerenderers, which collect
+ * the metadata in their own runtime rather than in the build's collectors.
+ */
+export interface PrerenderResult {
+    response: Response;
+    metadata?: PrerenderRenderMetadata;
 }
 /**
  * Custom prerenderer that adapters can provide to control how pages are prerendered.
@@ -217,10 +239,15 @@ export interface AstroPrerenderer {
      *   use the `pathname` from the `PathWithRoute` entry returned by `getStaticPaths`.
      * @param options - Render options
      * @param options.routeData - The matched route for this path
+     * @returns A `Response`, or a {@link PrerenderResult} pairing the response with
+     *   the incremental-build metadata the page resolved. Out-of-process
+     *   prerenderers return the latter to report metadata they collect in their own
+     *   runtime; in-process prerenderers populate the build's collectors directly
+     *   and return a bare `Response`.
      */
     render: (request: Request, options: {
         routeData: RouteData;
-    }) => Promise<Response>;
+    }) => Promise<Response | PrerenderResult>;
     /**
      * Returns images collected in the adapter's runtime (e.g. workerd) to be merged
      * into the Node-side static image list. The default Sharp pipeline runs after.

package/dist/types/public/preview.d.ts

@@ -1,8 +1,10 @@
 import type { OutgoingHttpHeaders } from 'node:http';
+import type { ResolvedServerUrls } from 'vite';
 import type { AstroIntegrationLogger } from '../../core/logger/core.js';
 export interface PreviewServer {
     host?: string;
     port: number;
+    urls?: ResolvedServerUrls;
     closed(): Promise<void>;
     stop(): Promise<void>;
 }

package/dist/vite-plugin-config-alias/index.js

@@ -68,6 +68,7 @@ function configAliasVitePlugin({
           let hasReplacement = false;
           const replaceAliases = (match, importId) => {
             if (!importId) return match;
+            if (importId.startsWith("data:")) return match;
             const resolved = resolveWithAlias(importId, configAlias);
             if (resolved) {
               hasReplacement = true;

package/dist/vite-plugin-environment/index.js

@@ -16,7 +16,10 @@ const ALWAYS_NOEXTERNAL = [
   // Full explanation and related bug report: https://github.com/withastro/astro/pull/3667
   "@nanostores/preact",
   // fontsource packages are CSS that need to be processed
-  "@fontsource/*"
+  "@fontsource/*",
+  // Must be bundled so the prerender output resolves Astro's own copy, not an
+  // older hoisted version from another dependency. See https://github.com/withastro/astro/issues/17508
+  "neotraverse"
 ];
 function vitePluginEnvironment({
   command,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "7.1.6",
+  "version": "7.2.0",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -100,7 +100,6 @@
     "@capsizecss/unpack": "^4.0.0",
     "@clack/prompts": "^1.1.0",
     "@oslojs/encoding": "^1.1.0",
-    "@rollup/pluginutils": "^5.3.0",
     "am-i-vibing": "^0.4.0",
     "aria-query": "^5.3.2",
     "axobject-query": "^4.1.0",