astro 3.4.4 → 3.5.1

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

@@ -0,0 +1,62 @@
+import * as vite from "vite";
+const virtualModuleId = "astro:i18n";
+const resolvedVirtualModuleId = "\0" + virtualModuleId;
+function astroInternationalization({
+  settings
+}) {
+  return {
+    name: "astro:i18n",
+    enforce: "pre",
+    async resolveId(id) {
+      if (id === virtualModuleId) {
+        return resolvedVirtualModuleId;
+      }
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        return `
+					import { 
+						getLocaleRelativeUrl as _getLocaleRelativeUrl, 
+						getLocaleRelativeUrlList as _getLocaleRelativeUrlList,
+						getLocaleAbsoluteUrl as _getLocaleAbsoluteUrl, 
+						getLocaleAbsoluteUrlList as _getLocaleAbsoluteUrlList,
+						 
+					} from "astro/i18n";
+					
+					const base =  ${JSON.stringify(settings.config.base)};
+					const trailingSlash =  ${JSON.stringify(settings.config.trailingSlash)};
+					const format =  ${JSON.stringify(settings.config.build.format)};
+					const site = ${JSON.stringify(settings.config.site)};
+					const i18n = ${JSON.stringify(settings.config.experimental.i18n)};
+					
+					export const getRelativeLocaleUrl = (locale, path = "", opts) => _getLocaleRelativeUrl({ 
+						locale,
+						path, 
+						base, 
+						trailingSlash, 
+						format,
+						...i18n,
+						...opts 
+					});
+					export const getAbsoluteLocaleUrl = (locale, path = "", opts) => _getLocaleAbsoluteUrl({ 
+						locale, 
+						path, 
+						base, 
+						trailingSlash, 
+						format, 
+						site, 
+						...i18n,
+						...opts 
+					});
+					
+					export const getRelativeLocaleUrlList = (path = "", opts) => _getLocaleRelativeUrlList({ 
+						base, path, trailingSlash, format, ...i18n, ...opts });
+					export const getAbsoluteLocaleUrlList = (path = "", opts) => _getLocaleAbsoluteUrlList({ base, path, trailingSlash, format, site, ...i18n, ...opts });
+				`;
+      }
+    }
+  };
+}
+export {
+  astroInternationalization as default
+};

package/dist/integrations/astroFeaturesValidation.js

@@ -11,7 +11,10 @@ const ALL_UNSUPPORTED = {
   serverOutput: UNSUPPORTED,
   staticOutput: UNSUPPORTED,
   hybridOutput: UNSUPPORTED,
-  assets: UNSUPPORTED_ASSETS_FEATURE
+  assets: UNSUPPORTED_ASSETS_FEATURE,
+  i18n: {
+    detectBrowserLanguage: UNSUPPORTED
+  }
 };
 function validateSupportedFeatures(adapterName, featureMap = ALL_UNSUPPORTED, config, logger) {
   const {

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 {