astro 3.4.4 → 3.5.0

package/client.d.ts

@@ -119,6 +119,92 @@ declare module 'astro:transitions/client' {
 	export const supportsViewTransitions: TransitionRouterModule['supportsViewTransitions'];
 	export const transitionEnabledOnThisPage: TransitionRouterModule['transitionEnabledOnThisPage'];
 	export const navigate: TransitionRouterModule['navigate'];
+	export type Options = import('./dist/transitions/router.js').Options;
+}
+
+declare module 'astro:prefetch' {
+	export { prefetch, PrefetchOptions } from 'astro/prefetch';
+}
+
+declare module 'astro:i18n' {
+	export type GetLocaleOptions = import('./dist/i18n/index.js').GetLocaleOptions;
+
+	/**
+	 * @param {string} locale A locale
+	 * @param {string} [path=""] An optional path to add after the `locale`.
+	 * @param {import('./dist/i18n/index.js').GetLocaleOptions} options Customise the generated path
+	 * @return {string}
+	 *
+	 * Returns a _relative_ path with passed locale.
+	 *
+	 * ## Errors
+	 *
+	 * Throws an error if the locale doesn't exist in the list of locales defined in the configuration.
+	 *
+	 * ## Examples
+	 *
+	 * ```js
+	 * import { getRelativeLocaleUrl } from "astro:i18n";
+	 * getRelativeLocaleUrl("es"); // /es
+	 * getRelativeLocaleUrl("es", "getting-started"); // /es/getting-started
+	 * getRelativeLocaleUrl("es_US", "getting-started", { prependWith: "blog" }); // /blog/es-us/getting-started
+	 * getRelativeLocaleUrl("es_US", "getting-started", { prependWith: "blog", normalizeLocale: false }); // /blog/es_US/getting-started
+	 * ```
+	 */
+	export const getRelativeLocaleUrl: (
+		locale: string,
+		path?: string,
+		options?: GetLocaleOptions
+	) => string;
+
+	/**
+	 *
+	 * @param {string} locale A locale
+	 * @param {string} [path=""] An optional path to add after the `locale`.
+	 * @param {import('./dist/i18n/index.js').GetLocaleOptions} options Customise the generated path
+	 * @return {string}
+	 *
+	 * Returns an absolute path with the passed locale. The behaviour is subject to change based on `site` configuration.
+	 * If _not_ provided, the function will return a _relative_ URL.
+	 *
+	 * ## Errors
+	 *
+	 * Throws an error if the locale doesn't exist in the list of locales defined in the configuration.
+	 *
+	 * ## Examples
+	 *
+	 * If `site` is `https://example.com`:
+	 *
+	 * ```js
+	 * import { getAbsoluteLocaleUrl } from "astro:i18n";
+	 * getAbsoluteLocaleUrl("es"); // https://example.com/es
+	 * getAbsoluteLocaleUrl("es", "getting-started"); // https://example.com/es/getting-started
+	 * getAbsoluteLocaleUrl("es_US", "getting-started", { prependWith: "blog" }); // https://example.com/blog/es-us/getting-started
+	 * getAbsoluteLocaleUrl("es_US", "getting-started", { prependWith: "blog", normalizeLocale: false }); // https://example.com/blog/es_US/getting-started
+	 * ```
+	 */
+	export const getAbsoluteLocaleUrl: (
+		locale: string,
+		path?: string,
+		options?: GetLocaleOptions
+	) => string;
+
+	/**
+	 * @param {string} [path=""] An optional path to add after the `locale`.
+	 * @param {import('./dist/i18n/index.js').GetLocaleOptions} options Customise the generated path
+	 * @return {string[]}
+	 *
+	 * Works like `getRelativeLocaleUrl` but it emits the relative URLs for ALL locales:
+	 */
+	export const getRelativeLocaleUrlList: (path?: string, options?: GetLocaleOptions) => string[];
+	/**
+	 * @param {string} [path=""] An optional path to add after the `locale`.
+	 * @param {import('./dist/i18n/index.js').GetLocaleOptions} options Customise the generated path
+	 * @return {string[]}
+	 *
+	 * Works like `getAbsoluteLocaleUrl` but it emits the absolute URLs for ALL locales:
+	 */
+	export const getAbsoluteLocaleUrlList: (path?: string, options?: GetLocaleOptions) => string[];
 }
 
 declare module 'astro:middleware' {

package/components/Code.astro

@@ -32,6 +32,11 @@ interface Props {
 	 * @default "github-dark"
 	 */
 	theme?: BuiltinTheme | ThemeRegistration | ThemeRegistrationRaw;
+	/**
+	 * Multiple themes to style with -- alternative to "theme" option.
+	 * Supports all themes found above; see https://github.com/antfu/shikiji#lightdark-dual-themes for more information.
+	 */
+	experimentalThemes?: Record<string, BuiltinTheme | ThemeRegistration | ThemeRegistrationRaw>;
 	/**
 	 * Enable word wrapping.
 	 *  - true: enabled.
@@ -53,6 +58,7 @@ const {
 	code,
 	lang = 'plaintext',
 	theme = 'github-dark',
+	experimentalThemes = {},
 	wrap = false,
 	inline = false,
 } = Astro.props;
@@ -88,12 +94,15 @@ if (typeof lang === 'object') {
 
 const highlighter = await getCachedHighlighter({
 	langs: [lang],
-	themes: [theme],
+	themes: Object.values(experimentalThemes).length ? Object.values(experimentalThemes) : [theme],
 });
 
+const themeOptions = Object.values(experimentalThemes).length
+	? { themes: experimentalThemes }
+	: { theme };
 const html = highlighter.codeToHtml(code, {
 	lang: typeof lang === 'string' ? lang : lang.name,
-	theme,
+	...themeOptions,
 	transforms: {
 		pre(node) {
 			// Swap to `code` tag if inline
@@ -123,6 +132,10 @@ const html = highlighter.codeToHtml(code, {
 			}
 		},
 		root(node) {
+			if (Object.values(experimentalThemes).length) {
+				return;
+			}
+
 			// theme.id for shiki -> shikiji compat
 			const themeName = typeof theme === 'string' ? theme : theme.name;
 			if (themeName === 'css-variables') {

package/components/Picture.astro

@@ -17,8 +17,9 @@ const defaultFallbackFormat = 'png' as const;
 // Certain formats don't want PNG fallbacks:
 // - GIF will typically want to stay as a gif, either for animation or for the lower amount of colors
 // - SVGs can't be converted to raster formats in most cases
+// - JPEGs compress photographs and high-noise images better than PNG in most cases
 // For those, we'll use the original format as the fallback instead.
-const specialFormatsFallback = ['gif', 'svg'] as const;
+const specialFormatsFallback = ['gif', 'svg', 'jpg', 'jpeg'] as const;
 
 const { formats = defaultFormats, pictureAttributes = {}, fallbackFormat, ...props } = Astro.props;
 

package/components/ViewTransitions.astro

@@ -3,9 +3,10 @@ type Fallback = 'none' | 'animate' | 'swap';
 
 export interface Props {
 	fallback?: Fallback;
+	handleForms?: boolean;
 }
 
-const { fallback = 'animate' } = Astro.props;
+const { fallback = 'animate', handleForms } = Astro.props;
 ---
 
 <style is:global>
@@ -24,12 +25,13 @@ const { fallback = 'animate' } = Astro.props;
 </style>
 <meta name="astro-view-transitions-enabled" content="true" />
 <meta name="astro-view-transitions-fallback" content={fallback} />
+{handleForms ? <meta name="astro-view-transitions-forms" content="true" /> : ''}
 <script>
-	import {
-		supportsViewTransitions,
-		transitionEnabledOnThisPage,
-		navigate,
-	} from 'astro:transitions/client';
+	import type { Options } from 'astro:transitions/client';
+	import { supportsViewTransitions, navigate } from 'astro:transitions/client';
+	// NOTE: import from `astro/prefetch` as `astro:prefetch` requires the `prefetch` config to be enabled
+	import { init } from 'astro/prefetch';
+
 	export type Fallback = 'none' | 'animate' | 'swap';
 
 	function getFallback(): Fallback {
@@ -40,19 +42,8 @@ const { fallback = 'animate' } = Astro.props;
 		return 'animate';
 	}
 
-	// Prefetching
-	function maybePrefetch(pathname: string) {
-		if (document.querySelector(`link[rel=prefetch][href="${pathname}"]`)) return;
-		// @ts-expect-error: connection might exist
-		if (navigator.connection) {
-			// @ts-expect-error: connection does exist
-			let conn = navigator.connection;
-			if (conn.saveData || /(2|3)g/.test(conn.effectiveType || '')) return;
-		}
-		let link = document.createElement('link');
-		link.setAttribute('rel', 'prefetch');
-		link.setAttribute('href', pathname);
-		document.head.append(link);
+	function isReloadEl(el: HTMLElement): boolean {
+		return el.dataset.astroReload !== undefined;
 	}
 
 	if (supportsViewTransitions || getFallback() !== 'none') {
@@ -67,7 +58,7 @@ const { fallback = 'animate' } = Astro.props;
 			if (
 				!link ||
 				!(link instanceof HTMLAnchorElement) ||
-				link.dataset.astroReload !== undefined ||
+				isReloadEl(link) ||
 				link.hasAttribute('download') ||
 				!link.href ||
 				(link.target && link.target !== '_self') ||
@@ -89,23 +80,33 @@ const { fallback = 'animate' } = Astro.props;
 			});
 		});
 
-		['mouseenter', 'touchstart', 'focus'].forEach((evName) => {
-			document.addEventListener(
-				evName,
-				(ev) => {
-					if (ev.target instanceof HTMLAnchorElement) {
-						let el = ev.target;
-						if (
-							el.origin === location.origin &&
-							el.pathname !== location.pathname &&
-							transitionEnabledOnThisPage()
-						) {
-							maybePrefetch(el.pathname);
-						}
-					}
-				},
-				{ passive: true, capture: true }
-			);
-		});
+		if (document.querySelector('[name="astro-view-transitions-forms"]')) {
+			document.addEventListener('submit', (ev) => {
+				let el = ev.target as HTMLElement;
+				if (el.tagName !== 'FORM' || isReloadEl(el)) {
+					return;
+				}
+
+				const form = el as HTMLFormElement;
+				const formData = new FormData(form);
+				let action = form.action;
+				const options: Options = {};
+				if (form.method === 'get') {
+					const params = new URLSearchParams(formData as any);
+					const url = new URL(action);
+					url.search = params.toString();
+					action = url.toString();
+				} else {
+					options.formData = formData;
+				}
+				ev.preventDefault();
+				navigate(action, options);
+			});
+		}
+
+		// @ts-expect-error injected by vite-plugin-transitions for treeshaking
+		if (!__PREFETCH_DISABLED__) {
+			init({ prefetchAll: true });
+		}
 	}
 </script>

package/content-module.template.mjs

@@ -9,21 +9,18 @@ import {
 	createReference,
 } from 'astro/content/runtime';
 
+export { defineCollection } from 'astro/content/runtime';
 export { z } from 'astro/zod';
 
 const contentDir = '@@CONTENT_DIR@@';
 
-const contentEntryGlob = import.meta.glob('@@CONTENT_ENTRY_GLOB_PATH@@', {
-	query: { astroContentCollectionEntry: true },
-});
+const contentEntryGlob = '@@CONTENT_ENTRY_GLOB_PATH@@';
 const contentCollectionToEntryMap = createCollectionToGlobResultMap({
 	globResult: contentEntryGlob,
 	contentDir,
 });
 
-const dataEntryGlob = import.meta.glob('@@DATA_ENTRY_GLOB_PATH@@', {
-	query: { astroDataCollectionEntry: true },
-});
+const dataEntryGlob = '@@DATA_ENTRY_GLOB_PATH@@';
 const dataCollectionToEntryMap = createCollectionToGlobResultMap({
 	globResult: dataEntryGlob,
 	contentDir,
@@ -45,19 +42,12 @@ function createGlobLookup(glob) {
 	};
 }
 
-const renderEntryGlob = import.meta.glob('@@RENDER_ENTRY_GLOB_PATH@@', {
-	query: { astroRenderContent: true },
-});
+const renderEntryGlob = '@@RENDER_ENTRY_GLOB_PATH@@';
 const collectionToRenderEntryMap = createCollectionToGlobResultMap({
 	globResult: renderEntryGlob,
 	contentDir,
 });
 
-export function defineCollection(config) {
-	if (!config.type) config.type = 'content';
-	return config;
-}
-
 export const getCollection = createGetCollection({
 	contentCollectionToEntryMap,
 	dataCollectionToEntryMap,

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

@@ -464,6 +464,67 @@ export interface AstroUserConfig {
      * ```
      */
     redirects?: Record<string, RedirectConfig>;
+    /**
+     * @docs
+     * @name prefetch
+     * @type {boolean | object}
+     * @description
+     * Enable prefetching for links on your site to provide faster page transitions.
+     * (Enabled by default on pages using the `<ViewTransitions />` router. Set `prefetch: false` to opt out of this behaviour.)
+     *
+     * This configuration automatically adds a prefetch script to every page in the project
+     * giving you access to the `data-astro-prefetch` attribute.
+     * Add this attribute to any `<a />` link on your page to enable prefetching for that page.
+     *
+     * ```html
+     * <a href="/about" data-astro-prefetch>About</a>
+     * ```
+     * Further customize the default prefetching behavior using the [`prefetch.defaultStrategy`](#prefetchdefaultstrategy) and [`prefetch.prefetchAll`](#prefetchprefetchall) options.
+     *
+     * See the [Prefetch guide](https://docs.astro.build/en/guides/prefetch/) for more information.
+     */
+    prefetch?: boolean | {
+        /**
+         * @docs
+         * @name prefetch.prefetchAll
+         * @type {boolean}
+         * @description
+         * Enable prefetching for all links, including those without the `data-astro-prefetch` attribute.
+         * This value defaults to `true` when using the `<ViewTransitions />` router. Otherwise, the default value is `false`.
+         *
+         * ```js
+         * prefetch: {
+         * 	prefetchAll: true
+         * }
+         * ```
+         *
+         * When set to `true`, you can disable prefetching individually by setting `data-astro-prefetch="false"` on any individual links.
+         *
+         * ```html
+         * <a href="/about" data-astro-prefetch="false">About</a>
+         *```
+         */
+        prefetchAll?: boolean;
+        /**
+         * @docs
+         * @name prefetch.defaultStrategy
+         * @type {'tap' | 'hover' | 'viewport'}
+         * @default `'hover'`
+         * @description
+         * The default prefetch strategy to use when the `data-astro-prefetch` attribute is set on a link with no value.
+         *
+         * - `'tap'`: Prefetch just before you click on the link.
+         * - `'hover'`: Prefetch when you hover over or focus on the link. (default)
+         * - `'viewport'`: Prefetch as the links enter the viewport.
+         *
+         * You can override this default value and select a different strategy for any individual link by setting a value on the attribute.
+         *
+         * ```html
+         * <a href="/about" data-astro-prefetch="viewport">About</a>
+         * ```
+         */
+        defaultStrategy?: 'tap' | 'hover' | 'viewport';
+    };
     /**
      * @docs
      * @name site
@@ -1275,6 +1336,107 @@ export interface AstroUserConfig {
          * ```
          */
         devOverlay?: boolean;
+        /**
+         * @docs
+         * @name experimental.i18n
+         * @type {object}
+         * @version 3.5.0
+         * @type {object}
+         * @description
+         *
+         * Configures experimental i18n routing and allows you to specify some customization options.
+         */
+        i18n?: {
+            /**
+             * @docs
+             * @name experimental.i18n.defaultLocale
+             * @type {string}
+             * @version 3.5.0
+             * @description
+             *
+             * The default locale of your website/application. This is a required field.
+             */
+            defaultLocale: string;
+            /**
+             * @docs
+             * @name experimental.i18n.locales
+             * @type {string[]}
+             * @version 3.5.0
+             * @description
+             *
+             * A list of all locales supported by the website (e.g. `['en', 'es', 'pt_BR']`). This list should also include the `defaultLocale`. This is a required field.
+             *
+             * No particular language format or syntax is enforced, but your folder structure must match exactly the locales in the list.
+             */
+            locales: string[];
+            /**
+             * @docs
+             * @name experimental.i18n.fallback
+             * @type {Record<string, string>}
+             * @version 3.5.0
+             * @description
+             *
+             * The fallback strategy when navigating to pages that do not exist (e.g. a translated page has not been created).
+             *
+             * Use this object to declare a fallback `locale` route for each language you support. If no fallback is specified, then unavailable pages will return a 404.
+             *
+             * #### Example
+             *
+             * The following example configures your content fallback strategy to redirect unavailable pages in `/pt/` to their `es` version, and unavailable pages in `/fr/` to their `en` version. Unavailable `/es/` pages will return a 404.
+             *
+             * ```js
+             * export defualt defineConfig({
+             * 	experimental: {
+             * 		i18n: {
+             * 			defaultLocale: "en",
+             * 			locales: ["en", "fr", "pt", "es"],
+             * 			fallback: {
+             * 				pt: "es",
+             * 			  fr: "en"
+             * 			}
+             * 		}
+             * 	}
+             * })
+             * ```
+             */
+            fallback?: Record<string, string>;
+            /**
+             * @docs
+             * @name experimental.i18n.routingStrategy
+             * @type {'prefix-always' | 'prefix-other-locales'}
+             * @default 'prefix-other-locales'
+             * @version 3.5.0
+             * @description
+             *
+             * Controls the routing strategy to determine your site URLs.
+             *
+             *  - `prefix-other-locales`(default): Only non-default languages will display a language prefix. The `defaultLocale` will not show a language prefix.
+             *    URLs will be of the form `example.com/[lang]/content/` for all non-default languages, but `example.com/content/` for the default locale.
+             *  - `prefix-always`: All URLs will display a language prefix.
+             *    URLs will be of the form `example.com/[lang]/content/` for every route, including the default language.
+             *
+             * Note: Astro requires all content to exist within a `/[lang]/` folder, even for the default language.
+             */
+            routingStrategy?: 'prefix-always' | 'prefix-other-locales';
+        };
+        /**
+         * @docs
+         * @name experimental.contentCollectionCache
+         * @type {boolean}
+         * @default `false`
+         * @version 3.5.0
+         * @description
+         * Enables a persistent cache for content collections when building in static mode.
+         *
+         * ```js
+         * {
+         * 	experimental: {
+         * 		contentCollectionCache: true,
+         * 	},
+         * }
+         * ```
+         */
+        contentCollectionCache?: boolean;
     };
 }
 /**
@@ -1332,10 +1494,6 @@ export interface AstroInlineOnlyConfig {
      * @default "info"
      */
     logLevel?: LoggerLevel;
-    /**
-     * @internal for testing only, use `logLevel` instead.
-     */
-    logger?: Logger;
 }
 export type ContentEntryModule = {
     id: string;
@@ -1426,6 +1584,10 @@ export interface AstroSettings {
      */
     clientDirectives: Map<string, string>;
     devOverlayPlugins: string[];
+    middlewares: {
+        pre: string[];
+        post: string[];
+    };
     tsConfig: TSConfig | undefined;
     tsConfigPath: string | undefined;
     watchFiles: string[];
@@ -1651,6 +1813,10 @@ export type AstroFeatureMap = {
      * The adapter can emit static assets
      */
     assets?: AstroAssetsFeature;
+    /**
+     * List of features that orbit around the i18n routing
+     */
+    i18n?: AstroInternationalizationFeature;
 };
 export interface AstroAssetsFeature {
     supportKind?: SupportsKind;
@@ -1663,6 +1829,12 @@ export interface AstroAssetsFeature {
      */
     isSquooshCompatible?: boolean;
 }
+export interface AstroInternationalizationFeature {
+    /**
+     * Whether the adapter is able to detect the language of the browser, usually using the `Accept-Language` header.
+     */
+    detectBrowserLanguage?: SupportsKind;
+}
 export interface AstroAdapter {
     name: string;
     serverEntrypoint?: string;
@@ -1712,6 +1884,14 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
      * Object accessed via Astro middleware
      */
     locals: App.Locals;
+    /**
+     * The current locale that is computed from the `Accept-Language` header of the browser (**SSR Only**).
+     */
+    preferredLocale: string | undefined;
+    /**
+     * The list of locales computed from the `Accept-Language` header of the browser, sorted by quality value (**SSR Only**).
+     */
+    preferredLocaleList: string[] | undefined;
 }
 export interface APIContext<Props extends Record<string, any> = Record<string, any>, APIParams extends Record<string, string | undefined> = Record<string, string | undefined>> extends AstroSharedContext<Props, Params> {
     site: URL | undefined;
@@ -1808,6 +1988,32 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
      */
     locals: App.Locals;
     ResponseWithEncoding: typeof ResponseWithEncoding;
+    /**
+     * Available only when `experimental.i18n` enabled and in SSR.
+     *
+     * It represents the preferred locale of the user. It's computed by checking the supported locales in `i18n.locales`
+     * and locales supported by the users's browser via the header `Accept-Language`
+     *
+     * For example, given `i18n.locales` equals to `['fr', 'de']`, and the `Accept-Language` value equals to `en, de;q=0.2, fr;q=0.6`, the
+     * `Astro.preferredLanguage` will be `fr` because `en` is not supported, its [quality value] is the highest.
+     *
+     * [quality value]: https://developer.mozilla.org/en-US/docs/Glossary/Quality_values
+     */
+    preferredLocale: string | undefined;
+    /**
+     * Available only when `experimental.i18n` enabled and in SSR.
+     *
+     * It represents the list of the preferred locales that are supported by the application. The list is sorted via [quality value].
+     *
+     * For example, given `i18n.locales` equals to `['fr', 'pt', 'de']`, and the `Accept-Language` value equals to `en, de;q=0.2, fr;q=0.6`, the
+     * `Astro.preferredLocaleList` will be equal to `['fs', 'de']` because `en` isn't supported, and `pt` isn't part of the locales contained in the
+     * header.
+     *
+     * When the `Accept-Header` is `*`, the original `i18n.locales` are returned. The value `*` means no preferences, so Astro returns all the supported locales.
+     *
+     * [quality value]: https://developer.mozilla.org/en-US/docs/Glossary/Quality_values
+     */
+    preferredLocaleList: string[] | undefined;
 }
 export type EndpointOutput = {
     body: Body;
@@ -1860,6 +2066,7 @@ export interface AstroIntegration {
             injectRoute: (injectRoute: InjectedRoute) => void;
             addClientDirective: (directive: ClientDirectiveConfig) => void;
             addDevOverlayPlugin: (entrypoint: string) => void;
+            addMiddleware: (mid: AstroIntegrationMiddleware) => void;
             logger: AstroIntegrationLogger;
         }) => void | Promise<void>;
         'astro:config:done'?: (options: {
@@ -1923,11 +2130,21 @@ export type MiddlewareNextResponse = MiddlewareNext<Response>;
 export type AstroMiddlewareInstance<R> = {
     onRequest?: MiddlewareHandler<R>;
 };
+export type AstroIntegrationMiddleware = {
+    order: 'pre' | 'post';
+    entrypoint: string;
+};
 export interface AstroPluginOptions {
     settings: AstroSettings;
     logger: Logger;
 }
-export type RouteType = 'page' | 'endpoint' | 'redirect';
+/**
+ * - page: a route that lives in the file system, usually an Astro component
+ * - endpoint: a route that lives in the file system, usually a JS file that exposes endpoints methods
+ * - redirect: a route points to another route that lives in the file system
+ * - fallback: a route that doesn't exist in the file system that needs to be handled with other means, usually the middleware
+ */
+export type RouteType = 'page' | 'endpoint' | 'redirect' | 'fallback';
 export interface RoutePart {
     content: string;
     dynamic: boolean;

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

@@ -6,6 +6,7 @@ import type { MapValue } from '../../type-utils.js';
 import type { AssetsGlobalStaticImagesList } from '../types.js';
 type AssetEnv = {
     logger: Logger;
+    isSSR: boolean;
     count: {
         total: number;
         current: number;
@@ -18,6 +19,6 @@ type AssetEnv = {
     assetsFolder: AstroConfig['build']['assets'];
 };
 export declare function prepareAssetsGenerationEnv(pipeline: BuildPipeline, totalCount: number): Promise<AssetEnv>;
-export declare function generateImagesForPath(originalFilePath: string, transforms: MapValue<AssetsGlobalStaticImagesList>, env: AssetEnv, queue: PQueue): Promise<void>;
+export declare function generateImagesForPath(originalFilePath: string, transformsAndPath: MapValue<AssetsGlobalStaticImagesList>, env: AssetEnv, queue: PQueue): Promise<void>;
 export declare function getStaticImageList(): AssetsGlobalStaticImagesList;
 export {};

package/dist/assets/build/generate.js

@@ -33,6 +33,7 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
   }
   return {
     logger,
+    isSSR: isServerLikeOutput(config),
     count,
     useCache,
     assetsCacheDir,
@@ -42,13 +43,25 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
     assetsFolder: config.build.assets
   };
 }
-async function generateImagesForPath(originalFilePath, transforms, env, queue) {
+function getFullImagePath(originalFilePath, env) {
+  return new URL(
+    "." + prependForwardSlash(join(env.assetsFolder, basename(originalFilePath))),
+    env.serverRoot
+  );
+}
+async function generateImagesForPath(originalFilePath, transformsAndPath, env, queue) {
   const originalImageData = await loadImage(originalFilePath, env);
-  for (const [_, transform] of transforms) {
+  for (const [_, transform] of transformsAndPath.transforms) {
     queue.add(
       async () => generateImage(originalImageData, transform.finalPath, transform.transform)
     );
   }
+  if (!env.isSSR && !isRemotePath(originalFilePath) && !globalThis.astroAsset.referencedImages?.has(transformsAndPath.originalSrcPath)) {
+    try {
+      await fs.promises.unlink(getFullImagePath(originalFilePath, env));
+    } catch (e) {
+    }
+  }
   async function generateImage(originalImage, filepath, options) {
     const timeStart = performance.now();
     const generationData = await generateImageInternal(originalImage, filepath, options);
@@ -156,9 +169,7 @@ async function loadImage(path, env) {
     };
   }
   return {
-    data: await fs.promises.readFile(
-      new URL("." + prependForwardSlash(join(env.assetsFolder, basename(path))), env.serverRoot)
-    ),
+    data: await fs.promises.readFile(getFullImagePath(path, env)),
     expires: 0
   };
 }

package/dist/assets/consts.d.ts

@@ -8,3 +8,4 @@ export declare const VALID_INPUT_FORMATS: readonly ["jpeg", "jpg", "png", "tiff"
 export declare const VALID_SUPPORTED_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif", "svg", "avif"];
 export declare const DEFAULT_OUTPUT_FORMAT: "webp";
 export declare const VALID_OUTPUT_FORMATS: readonly ["avif", "png", "webp", "jpeg", "jpg", "svg"];
+export declare const DEFAULT_HASH_PROPS: string[];