astro 3.4.4 → 3.5.0

package/dist/integrations/index.js

@@ -94,6 +94,18 @@ async function runHookConfigSetup({
           }
           addedClientDirectives.set(name, buildClientDirectiveEntrypoint(name, entrypoint));
         },
+        addMiddleware: ({ order, entrypoint }) => {
+          if (typeof updatedSettings.middlewares[order] === "undefined") {
+            throw new Error(
+              `The "${integration.name}" integration is trying to add middleware but did not specify an order.`
+            );
+          }
+          logger.debug(
+            "middleware",
+            `The integration ${integration.name} has added middleware that runs ${order === "pre" ? "before" : "after"} any application middleware you define.`
+          );
+          updatedSettings.middlewares[order].push(entrypoint);
+        },
         logger: integrationLogger
       };
       Object.defineProperty(hooks, "addPageExtension", {

package/dist/prefetch/index.d.ts

@@ -0,0 +1,31 @@
+interface InitOptions {
+    defaultStrategy?: string;
+    prefetchAll?: boolean;
+}
+/**
+ * Initialize the prefetch script, only works once.
+ *
+ * @param defaultOpts Default options for prefetching if not already set by the user config.
+ */
+export declare function init(defaultOpts?: InitOptions): void;
+export interface PrefetchOptions {
+    /**
+     * How the prefetch should prioritize the URL. (default `'link'`)
+     * - `'link'`: use `<link rel="prefetch">`, has lower loading priority.
+     * - `'fetch'`: use `fetch()`, has higher loading priority.
+     */
+    with?: 'link' | 'fetch';
+}
+/**
+ * Prefetch a URL so it's cached when the user navigates to it.
+ *
+ * @param url A full or partial URL string based on the current `location.href`. They are only fetched if:
+ *   - The user is online
+ *   - The user is not in data saver mode
+ *   - The URL is within the same origin
+ *   - The URL is not the current page
+ *   - The URL has not already been prefetched
+ * @param opts Additional options for prefetching.
+ */
+export declare function prefetch(url: string, opts?: PrefetchOptions): void;
+export {};

package/dist/prefetch/index.js

@@ -0,0 +1,176 @@
+const debug = import.meta.env.DEV ? console.debug : void 0;
+const inBrowser = import.meta.env.SSR === false;
+const prefetchedUrls = /* @__PURE__ */ new Set();
+const listenedAnchors = /* @__PURE__ */ new WeakSet();
+let prefetchAll = __PREFETCH_PREFETCH_ALL__;
+let defaultStrategy = __PREFETCH_DEFAULT_STRATEGY__;
+let inited = false;
+function init(defaultOpts) {
+  if (!inBrowser)
+    return;
+  if (inited)
+    return;
+  inited = true;
+  debug?.(`[astro] Initializing prefetch script`);
+  prefetchAll ??= defaultOpts?.prefetchAll ?? false;
+  defaultStrategy ??= defaultOpts?.defaultStrategy ?? "hover";
+  initTapStrategy();
+  initHoverStrategy();
+  initViewportStrategy();
+}
+function initTapStrategy() {
+  for (const event of ["touchstart", "mousedown"]) {
+    document.body.addEventListener(
+      event,
+      (e) => {
+        if (elMatchesStrategy(e.target, "tap")) {
+          prefetch(e.target.href, { with: "fetch" });
+        }
+      },
+      { passive: true }
+    );
+  }
+}
+function initHoverStrategy() {
+  let timeout;
+  document.body.addEventListener(
+    "focusin",
+    (e) => {
+      if (elMatchesStrategy(e.target, "hover")) {
+        handleHoverIn(e);
+      }
+    },
+    { passive: true }
+  );
+  document.body.addEventListener("focusout", handleHoverOut, { passive: true });
+  onPageLoad(() => {
+    for (const anchor of document.getElementsByTagName("a")) {
+      if (listenedAnchors.has(anchor))
+        continue;
+      if (elMatchesStrategy(anchor, "hover")) {
+        listenedAnchors.add(anchor);
+        anchor.addEventListener("mouseenter", handleHoverIn, { passive: true });
+        anchor.addEventListener("mouseleave", handleHoverOut, { passive: true });
+      }
+    }
+  });
+  function handleHoverIn(e) {
+    const href = e.target.href;
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      prefetch(href, { with: "fetch" });
+    }, 80);
+  }
+  function handleHoverOut() {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = 0;
+    }
+  }
+}
+function initViewportStrategy() {
+  let observer;
+  onPageLoad(() => {
+    for (const anchor of document.getElementsByTagName("a")) {
+      if (listenedAnchors.has(anchor))
+        continue;
+      if (elMatchesStrategy(anchor, "viewport")) {
+        listenedAnchors.add(anchor);
+        observer ??= createViewportIntersectionObserver();
+        observer.observe(anchor);
+      }
+    }
+  });
+}
+function createViewportIntersectionObserver() {
+  const timeouts = /* @__PURE__ */ new WeakMap();
+  return new IntersectionObserver((entries, observer) => {
+    for (const entry of entries) {
+      const anchor = entry.target;
+      const timeout = timeouts.get(anchor);
+      if (entry.isIntersecting) {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        timeouts.set(
+          anchor,
+          setTimeout(() => {
+            observer.unobserve(anchor);
+            timeouts.delete(anchor);
+            prefetch(anchor.href, { with: "link" });
+          }, 300)
+        );
+      } else {
+        if (timeout) {
+          clearTimeout(timeout);
+          timeouts.delete(anchor);
+        }
+      }
+    }
+  });
+}
+function prefetch(url, opts) {
+  if (!canPrefetchUrl(url))
+    return;
+  prefetchedUrls.add(url);
+  const priority = opts?.with ?? "link";
+  debug?.(`[astro] Prefetching ${url} with ${priority}`);
+  if (priority === "link") {
+    const link = document.createElement("link");
+    link.rel = "prefetch";
+    link.setAttribute("href", url);
+    document.head.append(link);
+  } else {
+    fetch(url).catch((e) => {
+      console.log(`[astro] Failed to prefetch ${url}`);
+      console.error(e);
+    });
+  }
+}
+function canPrefetchUrl(url) {
+  if (!navigator.onLine)
+    return false;
+  if ("connection" in navigator) {
+    const conn = navigator.connection;
+    if (conn.saveData || /(2|3)g/.test(conn.effectiveType))
+      return false;
+  }
+  try {
+    const urlObj = new URL(url, location.href);
+    return location.origin === urlObj.origin && location.pathname !== urlObj.pathname && !prefetchedUrls.has(url);
+  } catch {
+  }
+  return false;
+}
+function elMatchesStrategy(el, strategy) {
+  if (el?.tagName !== "A")
+    return false;
+  const attrValue = el.dataset.astroPrefetch;
+  if (attrValue === "false") {
+    return false;
+  }
+  if (attrValue == null && prefetchAll || attrValue === "") {
+    return strategy === defaultStrategy;
+  }
+  if (attrValue === strategy) {
+    return true;
+  }
+  return false;
+}
+function onPageLoad(cb) {
+  cb();
+  let firstLoad = false;
+  document.addEventListener("astro:page-load", () => {
+    if (!firstLoad) {
+      firstLoad = true;
+      return;
+    }
+    cb();
+  });
+}
+export {
+  init,
+  prefetch
+};

package/dist/prefetch/vite-plugin-prefetch.d.ts

@@ -0,0 +1,5 @@
+import * as vite from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+export default function astroPrefetch({ settings }: {
+    settings: AstroSettings;
+}): vite.Plugin;

package/dist/prefetch/vite-plugin-prefetch.js

@@ -0,0 +1,43 @@
+import * as vite from "vite";
+const virtualModuleId = "astro:prefetch";
+const resolvedVirtualModuleId = "\0" + virtualModuleId;
+const prefetchInternalModuleFsSubpath = "astro/dist/prefetch/index.js";
+const prefetchCode = `import { init } from 'astro/prefetch';init()`;
+function astroPrefetch({ settings }) {
+  const prefetchOption = settings.config.prefetch;
+  const prefetch = prefetchOption ? typeof prefetchOption === "object" ? prefetchOption : {} : void 0;
+  if (prefetch && settings.scripts.every((s) => s.content !== prefetchCode)) {
+    settings.scripts.push({
+      stage: "page",
+      content: `import { init } from 'astro/prefetch';init()`
+    });
+  }
+  const throwPrefetchNotEnabledError = () => {
+    throw new Error("You need to enable the `prefetch` Astro config to import `astro:prefetch`");
+  };
+  return {
+    name: "astro:prefetch",
+    async resolveId(id) {
+      if (id === virtualModuleId) {
+        if (!prefetch)
+          throwPrefetchNotEnabledError();
+        return resolvedVirtualModuleId;
+      }
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        if (!prefetch)
+          throwPrefetchNotEnabledError();
+        return `export { prefetch } from "astro/prefetch";`;
+      }
+    },
+    transform(code, id) {
+      if (id.includes(prefetchInternalModuleFsSubpath)) {
+        return code.replace("__PREFETCH_PREFETCH_ALL__", JSON.stringify(prefetch?.prefetchAll)).replace("__PREFETCH_DEFAULT_STRATEGY__", JSON.stringify(prefetch?.defaultStrategy));
+      }
+    }
+  };
+}
+export {
+  astroPrefetch as default
+};

package/dist/runtime/client/dev-overlay/plugins/audit.js

@@ -84,12 +84,12 @@ var audit_default = {
       }
       const rect = originalElement.getBoundingClientRect();
       const highlight = createHighlight(rect, "warning");
-      const tooltip = buildAuditTooltip(rule);
+      const tooltip = buildAuditTooltip(rule, originalElement);
       attachTooltipToHighlight(highlight, tooltip, originalElement);
       canvas.append(highlight);
       audits.push({ highlightElement: highlight, auditedElement: originalElement });
     }
-    function buildAuditTooltip(rule) {
+    function buildAuditTooltip(rule, element) {
       const tooltip = document.createElement("astro-dev-overlay-tooltip");
       tooltip.sections = [
         {
@@ -99,14 +99,22 @@ var audit_default = {
         {
           content: rule.message
         }
-        // TODO: Add a link to the file
-        // Needs https://github.com/withastro/compiler/pull/375
-        // {
-        // 	content: '/src/somewhere/component.astro',
-        // 	clickDescription: 'Click to go to file',
-        // 	clickAction() {},
-        // },
       ];
+      const elementFile = element.getAttribute("data-astro-source-file");
+      const elementPosition = element.getAttribute("data-astro-source-loc");
+      if (elementFile) {
+        const elementFileWithPosition = elementFile + (elementPosition ? ":" + elementPosition : "");
+        tooltip.sections.push({
+          content: elementFileWithPosition.slice(
+            window.__astro_dev_overlay__.root.length - 1
+            // We want to keep the final slash, so minus one.
+          ),
+          clickDescription: "Click to go to file",
+          async clickAction() {
+            await fetch("/__open-in-editor?file=" + encodeURIComponent(elementFileWithPosition));
+          }
+        });
+      }
       return tooltip;
     }
     function initStyle() {

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

@@ -7,8 +7,6 @@ export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRe
 export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
 export { createTransitionScope, renderTransition } from './transition.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;
-/** @internal Associate JSX components with a specific renderer (see /src/vite-plugin-jsx/tag.ts) */
-export declare function __astro_tag_component__(Component: unknown, rendererName: string): void;
 export declare function spreadAttributes(values?: Record<any, any>, _name?: string, { class: scopedClassName }?: {
     class?: string;
 }): any;

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

@@ -6,11 +6,9 @@ import { extractDirectives, generateHydrateScript } from "../hydration.js";
 import { serializeProps } from "../serialize.js";
 import { shorthash } from "../shorthash.js";
 import { isPromise } from "../util.js";
-import {
-  createAstroComponentInstance,
-  isAstroComponentFactory,
-  renderTemplate
-} from "./astro/index.js";
+import { isAstroComponentFactory } from "./astro/factory.js";
+import { renderTemplate } from "./astro/index.js";
+import { createAstroComponentInstance } from "./astro/instance.js";
 import {
   Fragment,
   Renderer,

package/dist/transitions/router.d.ts

@@ -2,6 +2,7 @@ export type Fallback = 'none' | 'animate' | 'swap';
 export type Direction = 'forward' | 'back';
 export type Options = {
     history?: 'auto' | 'push' | 'replace';
+    formData?: FormData;
 };
 export declare const supportsViewTransitions: boolean;
 export declare const transitionEnabledOnThisPage: () => boolean;

package/dist/transitions/router.js

@@ -53,9 +53,9 @@ const throttle = (cb, delay) => {
     }, delay);
   };
 };
-async function fetchHTML(href) {
+async function fetchHTML(href, init) {
   try {
-    const res = await fetch(href);
+    const res = await fetch(href, init);
     const mediaType = res.headers.get("content-type")?.replace(/;.*$/, "");
     if (mediaType !== "text/html" && mediaType !== "application/xhtml+xml") {
       return null;
@@ -253,7 +253,12 @@ async function updateDOM(newDocument, toLocation, options, popState, fallback) {
 async function transition(direction, toLocation, options, popState) {
   let finished;
   const href = toLocation.href;
-  const response = await fetchHTML(href);
+  const init = {};
+  if (options.formData) {
+    init.method = "POST";
+    init.body = options.formData;
+  }
+  const response = await fetchHTML(href, init);
   if (response === null) {
     location.href = href;
     return;
@@ -264,7 +269,7 @@ async function transition(direction, toLocation, options, popState) {
   parser ??= new DOMParser();
   const newDocument = parser.parseFromString(response.html, response.mediaType);
   newDocument.querySelectorAll("noscript").forEach((el) => el.remove());
-  if (!newDocument.querySelector('[name="astro-view-transitions-enabled"]')) {
+  if (!newDocument.querySelector('[name="astro-view-transitions-enabled"]') && !options.formData) {
     location.href = href;
     return;
   }

package/dist/transitions/vite-plugin-transitions.d.ts

@@ -1,2 +1,5 @@
 import * as vite from 'vite';
-export default function astroTransitions(): vite.Plugin;
+import type { AstroSettings } from '../@types/astro.js';
+export default function astroTransitions({ settings }: {
+    settings: AstroSettings;
+}): vite.Plugin;

package/dist/transitions/vite-plugin-transitions.js

@@ -3,7 +3,7 @@ const virtualModuleId = "astro:transitions";
 const resolvedVirtualModuleId = "\0" + virtualModuleId;
 const virtualClientModuleId = "astro:transitions/client";
 const resolvedVirtualClientModuleId = "\0" + virtualClientModuleId;
-function astroTransitions() {
+function astroTransitions({ settings }) {
   return {
     name: "astro:transitions",
     async resolveId(id) {
@@ -26,6 +26,12 @@ function astroTransitions() {
 				export * from "astro/transitions/router";
 			`;
       }
+    },
+    transform(code, id) {
+      if (id.includes("ViewTransitions.astro") && id.endsWith(".ts")) {
+        const prefetchDisabled = settings.config.prefetch === false;
+        return code.replace("__PREFETCH_DISABLED__", JSON.stringify(prefetchDisabled));
+      }
     }
   };
 }

package/dist/vite-plugin-astro-server/devPipeline.d.ts

@@ -18,4 +18,5 @@ export default class DevPipeline extends Pipeline {
     get logger(): Readonly<Logger>;
     loadRenderers(): Promise<void>;
     static createDevelopmentEnvironment(manifest: SSRManifest, settings: AstroSettings, logger: Logger, loader: ModuleLoader): Environment;
+    handleFallback(): Promise<void>;
 }

package/dist/vite-plugin-astro-server/devPipeline.js

@@ -61,6 +61,8 @@ class DevPipeline extends Pipeline {
   async #handleEndpointResult(_, response) {
     return response;
   }
+  async handleFallback() {
+  }
 }
 export {
   DevPipeline as default

package/dist/vite-plugin-astro-server/plugin.js

@@ -59,6 +59,15 @@ function createVitePluginAstroServer({
   };
 }
 function createDevelopmentManifest(settings) {
+  let i18nManifest = void 0;
+  if (settings.config.experimental.i18n) {
+    i18nManifest = {
+      fallback: settings.config.experimental.i18n.fallback,
+      routingStrategy: settings.config.experimental.i18n.routingStrategy,
+      defaultLocale: settings.config.experimental.i18n.defaultLocale,
+      locales: settings.config.experimental.i18n.locales
+    };
+  }
   return {
     compressHTML: settings.config.compressHTML,
     assets: /* @__PURE__ */ new Set(),
@@ -70,7 +79,8 @@ function createDevelopmentManifest(settings) {
     base: settings.config.base,
     assetsPrefix: settings.config.build.assetsPrefix,
     site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
-    componentMetadata: /* @__PURE__ */ new Map()
+    componentMetadata: /* @__PURE__ */ new Map(),
+    i18n: i18nManifest
   };
 }
 export {

package/dist/vite-plugin-astro-server/route.js

@@ -1,10 +1,15 @@
 import { fileURLToPath } from "node:url";
 import { AstroErrorData, isAstroError } from "../core/errors/index.js";
+import { sequence } from "../core/middleware/index.js";
 import { loadMiddleware } from "../core/middleware/loadMiddleware.js";
-import { createRenderContext, getParamsAndProps } from "../core/render/index.js";
+import {
+  createRenderContext,
+  getParamsAndProps
+} from "../core/render/index.js";
 import { createRequest } from "../core/request.js";
 import { matchAllRoutes } from "../core/routing/index.js";
 import { isPage, resolveIdToUrl } from "../core/util.js";
+import { createI18nMiddleware } from "../i18n/middleware.js";
 import { getSortedPreloadedMatches } from "../prerender/routing.js";
 import { isServerLikeOutput } from "../prerender/utils.js";
 import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
@@ -22,7 +27,7 @@ function getCustom404Route(manifestData) {
 async function matchRoute(pathname, manifestData, pipeline) {
   const env = pipeline.getEnvironment();
   const { routeCache, logger } = env;
-  const matches = matchAllRoutes(pathname, manifestData);
+  let matches = matchAllRoutes(pathname, manifestData);
   const preloadedMatches = await getSortedPreloadedMatches({
     pipeline,
     matches,
@@ -96,67 +101,124 @@ async function handleRoute({
   manifest
 }) {
   const env = pipeline.getEnvironment();
-  const settings = pipeline.getSettings();
   const config = pipeline.getConfig();
   const moduleLoader = pipeline.getModuleLoader();
   const { logger } = env;
-  if (!matchedRoute) {
+  if (!matchedRoute && !config.experimental.i18n) {
     return handle404Response(origin, incomingRequest, incomingResponse);
   }
-  const filePath = matchedRoute.filePath;
-  const { route, preloadedComponent } = matchedRoute;
   const buildingToSSR = isServerLikeOutput(config);
-  const request = createRequest({
-    url,
-    headers: buildingToSSR ? incomingRequest.headers : new Headers(),
-    method: incomingRequest.method,
-    body,
-    logger,
-    ssr: buildingToSSR,
-    clientAddress: buildingToSSR ? incomingRequest.socket.remoteAddress : void 0,
-    locals: Reflect.get(incomingRequest, clientLocalsSymbol)
-    // Allows adapters to pass in locals in dev mode.
-  });
-  for (const [name, value] of Object.entries(config.server.headers ?? {})) {
-    if (value)
-      incomingResponse.setHeader(name, value);
-  }
-  const options = {
-    env,
-    filePath,
-    preload: preloadedComponent,
-    pathname,
-    request,
-    route
-  };
-  const middleware = await loadMiddleware(moduleLoader, settings.config.srcDir);
-  if (middleware) {
-    options.middleware = middleware;
+  let request;
+  let renderContext;
+  let mod = void 0;
+  let options = void 0;
+  let route;
+  const middleware = await loadMiddleware(moduleLoader);
+  if (!matchedRoute) {
+    if (config.experimental.i18n) {
+      const locales = config.experimental.i18n.locales;
+      const pathNameHasLocale = pathname.split("/").filter(Boolean).some((segment) => {
+        return locales.includes(segment);
+      });
+      if (!pathNameHasLocale && pathname !== "/") {
+        return handle404Response(origin, incomingRequest, incomingResponse);
+      }
+      request = createRequest({
+        url,
+        headers: buildingToSSR ? incomingRequest.headers : new Headers(),
+        logger,
+        ssr: buildingToSSR
+      });
+      route = {
+        component: "",
+        generate(_data) {
+          return "";
+        },
+        params: [],
+        pattern: new RegExp(""),
+        prerender: false,
+        segments: [],
+        type: "fallback",
+        route: ""
+      };
+      renderContext = await createRenderContext({
+        request,
+        pathname,
+        env,
+        mod,
+        route
+      });
+    } else {
+      return handle404Response(origin, incomingRequest, incomingResponse);
+    }
+  } else {
+    const filePath = matchedRoute.filePath;
+    const { preloadedComponent } = matchedRoute;
+    route = matchedRoute.route;
+    request = createRequest({
+      url,
+      headers: buildingToSSR ? incomingRequest.headers : new Headers(),
+      method: incomingRequest.method,
+      body,
+      logger,
+      ssr: buildingToSSR,
+      clientAddress: buildingToSSR ? incomingRequest.socket.remoteAddress : void 0,
+      locals: Reflect.get(incomingRequest, clientLocalsSymbol)
+      // Allows adapters to pass in locals in dev mode.
+    });
+    for (const [name, value] of Object.entries(config.server.headers ?? {})) {
+      if (value)
+        incomingResponse.setHeader(name, value);
+    }
+    options = {
+      env,
+      filePath,
+      preload: preloadedComponent,
+      pathname,
+      request,
+      route
+    };
+    if (middleware) {
+      options.middleware = middleware;
+    }
+    mod = options.preload;
+    const { scripts, links, styles, metadata } = await getScriptsAndStyles({
+      pipeline,
+      filePath: options.filePath
+    });
+    const i18n = pipeline.getConfig().experimental.i18n;
+    renderContext = await createRenderContext({
+      request: options.request,
+      pathname: options.pathname,
+      scripts,
+      links,
+      styles,
+      componentMetadata: metadata,
+      route: options.route,
+      mod,
+      env,
+      locales: i18n ? i18n.locales : void 0
+    });
   }
-  const mod = options.preload;
-  const { scripts, links, styles, metadata } = await getScriptsAndStyles({
-    pipeline,
-    filePath: options.filePath
-  });
-  const renderContext = await createRenderContext({
-    request: options.request,
-    pathname: options.pathname,
-    scripts,
-    links,
-    styles,
-    componentMetadata: metadata,
-    route: options.route,
-    mod,
-    env
-  });
-  const onRequest = options.middleware?.onRequest;
-  if (onRequest) {
+  const onRequest = middleware?.onRequest;
+  if (config.experimental.i18n) {
+    const i18Middleware = createI18nMiddleware(config.experimental.i18n, config.base);
+    if (i18Middleware) {
+      if (onRequest) {
+        pipeline.setMiddlewareFunction(sequence(i18Middleware, onRequest));
+      } else {
+        pipeline.setMiddlewareFunction(i18Middleware);
+      }
+    } else if (onRequest) {
+      pipeline.setMiddlewareFunction(onRequest);
+    }
+  } else if (onRequest) {
     pipeline.setMiddlewareFunction(onRequest);
   }
   let response = await pipeline.renderRoute(renderContext, mod);
   if (response.status === 404 && has404Route(manifestData)) {
     const fourOhFourRoute = await matchRoute("/404", manifestData, pipeline);
-    if (fourOhFourRoute?.route !== options.route)
+    if (options && fourOhFourRoute?.route !== options.route)
       return handleRoute({
         ...options,
         matchedRoute: fourOhFourRoute,

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

@@ -71,7 +71,7 @@ function configHeadVitePlugin() {
 }
 function astroHeadBuildPlugin(internals) {
   return {
-    build: "ssr",
+    targets: ["server"],
     hooks: {
       "build:before"() {
         return {