astro 3.4.3 → 3.5.0

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;
@@ -2058,6 +2275,7 @@ export interface DevOverlayPlugin {
     name: string;
     icon: Icon;
     init?(canvas: ShadowRoot, eventTarget: EventTarget): void | Promise<void>;
+    beforeTogglingOff?(canvas: ShadowRoot): boolean | Promise<boolean>;
 }
 export type DevOverlayMetadata = Window & typeof globalThis & {
     __astro_dev_overlay__: {

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[];

package/dist/assets/consts.js

@@ -22,7 +22,9 @@ const VALID_SUPPORTED_FORMATS = [
 ];
 const DEFAULT_OUTPUT_FORMAT = "webp";
 const VALID_OUTPUT_FORMATS = ["avif", "png", "webp", "jpeg", "jpg", "svg"];
+const DEFAULT_HASH_PROPS = ["src", "width", "height", "format", "quality"];
 export {
+  DEFAULT_HASH_PROPS,
   DEFAULT_OUTPUT_FORMAT,
   VALID_INPUT_FORMATS,
   VALID_OUTPUT_FORMATS,

package/dist/assets/endpoint/generic.js

@@ -9,7 +9,7 @@ async function loadRemoteImage(src) {
     if (!res.ok) {
       return void 0;
     }
-    return Buffer.from(await res.arrayBuffer());
+    return await res.arrayBuffer();
   } catch (err) {
     return void 0;
   }
@@ -34,7 +34,11 @@ const GET = async ({ request }) => {
     if (!inputBuffer) {
       return new Response("Not Found", { status: 404 });
     }
-    const { data, format } = await imageService.transform(inputBuffer, transform, imageConfig);
+    const { data, format } = await imageService.transform(
+      new Uint8Array(inputBuffer),
+      transform,
+      imageConfig
+    );
     return new Response(data, {
       status: 200,
       headers: {

package/dist/assets/internal.js

@@ -1,5 +1,6 @@
 import { isRemotePath } from "@astrojs/internal-helpers/path";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { DEFAULT_HASH_PROPS } from "./consts.js";
 import { isLocalService } from "./services/service.js";
 import { matchHostname, matchPattern } from "./utils/remotePattern.js";
 function injectImageEndpoint(settings, mode) {
@@ -55,20 +56,28 @@ async function getImage(options, imageConfig) {
     ...options,
     src: typeof options.src === "object" && "then" in options.src ? (await options.src).default ?? await options.src : options.src
   };
+  const clonedSrc = isESMImportedImage(resolvedOptions.src) ? (
+    // @ts-expect-error - clone is a private, hidden prop
+    resolvedOptions.src.clone ?? resolvedOptions.src
+  ) : resolvedOptions.src;
+  resolvedOptions.src = clonedSrc;
   const validatedOptions = service.validateOptions ? await service.validateOptions(resolvedOptions, imageConfig) : resolvedOptions;
   const srcSetTransforms = service.getSrcSet ? await service.getSrcSet(validatedOptions, imageConfig) : [];
   let imageURL = await service.getURL(validatedOptions, imageConfig);
   let srcSets = await Promise.all(
     srcSetTransforms.map(async (srcSet) => ({
+      transform: srcSet.transform,
       url: await service.getURL(srcSet.transform, imageConfig),
       descriptor: srcSet.descriptor,
       attributes: srcSet.attributes
     }))
   );
   if (isLocalService(service) && globalThis.astroAsset.addStaticImage && !(isRemoteImage(validatedOptions.src) && imageURL === validatedOptions.src)) {
-    imageURL = globalThis.astroAsset.addStaticImage(validatedOptions);
+    const propsToHash = service.propertiesToHash ?? DEFAULT_HASH_PROPS;
+    imageURL = globalThis.astroAsset.addStaticImage(validatedOptions, propsToHash);
     srcSets = srcSetTransforms.map((srcSet) => ({
-      url: globalThis.astroAsset.addStaticImage(srcSet.transform),
+      transform: srcSet.transform,
+      url: globalThis.astroAsset.addStaticImage(srcSet.transform, propsToHash),
       descriptor: srcSet.descriptor,
       attributes: srcSet.attributes
     }));

package/dist/assets/services/service.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { AstroConfig } from '../../@types/astro.js';
-import type { ImageOutputFormat, ImageTransform } from '../types.js';
+import type { ImageOutputFormat, ImageTransform, UnresolvedSrcSetValue } from '../types.js';
 export type ImageService = LocalImageService | ExternalImageService;
 export declare function isLocalService(service: ImageService | undefined): service is LocalImageService;
 export declare function parseQuality(quality: string): string | number;
@@ -10,11 +9,6 @@ type ImageConfig<T> = Omit<AstroConfig['image'], 'service'> & {
         config: T;
     };
 };
-type SrcSetValue = {
-    transform: ImageTransform;
-    descriptor?: string;
-    attributes?: Record<string, any>;
-};
 interface SharedServiceProps<T extends Record<string, any> = Record<string, any>> {
     /**
      * Return the URL to the endpoint or URL your images are generated from.
@@ -31,7 +25,7 @@ interface SharedServiceProps<T extends Record<string, any> = Record<string, any>
      * While in most cases this is exclusively used for `srcset`, it can also be used in a more generic way to generate
      * multiple variants of the same image. For instance, you can use this to generate multiple aspect ratios or multiple formats.
      */
-    getSrcSet?: (options: ImageTransform, imageConfig: ImageConfig<T>) => SrcSetValue[] | Promise<SrcSetValue[]>;
+    getSrcSet?: (options: ImageTransform, imageConfig: ImageConfig<T>) => UnresolvedSrcSetValue[] | Promise<UnresolvedSrcSetValue[]>;
     /**
      * Return any additional HTML attributes separate from `src` that your service requires to show the image properly.
      *
@@ -65,10 +59,16 @@ export interface LocalImageService<T extends Record<string, any> = Record<string
      * Performs the image transformations on the input image and returns both the binary data and
      * final image format of the optimized image.
      */
-    transform: (inputBuffer: Buffer, transform: LocalImageTransform, imageConfig: ImageConfig<T>) => Promise<{
-        data: Buffer;
+    transform: (inputBuffer: Uint8Array, transform: LocalImageTransform, imageConfig: ImageConfig<T>) => Promise<{
+        data: Uint8Array;
         format: ImageOutputFormat;
     }>;
+    /**
+     * A list of properties that should be used to generate the hash for the image.
+     *
+     * Generally, this should be all the properties that can change the result of the image. By default, this is `src`, `width`, `height`, `quality`, and `format`.
+     */
+    propertiesToHash?: string[];
 }
 export type BaseServiceTransform = {
     src: string;

package/dist/assets/services/service.js

@@ -1,6 +1,6 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { isRemotePath, joinPaths } from "../../core/path.js";
-import { DEFAULT_OUTPUT_FORMAT, VALID_SUPPORTED_FORMATS } from "../consts.js";
+import { DEFAULT_HASH_PROPS, DEFAULT_OUTPUT_FORMAT, VALID_SUPPORTED_FORMATS } from "../consts.js";
 import { isESMImportedImage, isRemoteAllowed } from "../internal.js";
 function isLocalService(service) {
   if (!service) {
@@ -16,6 +16,7 @@ function parseQuality(quality) {
   return result;
 }
 const baseService = {
+  propertiesToHash: DEFAULT_HASH_PROPS,
   validateOptions(options) {
     if (!options.src || typeof options.src !== "string" && typeof options.src !== "object") {
       throw new AstroError({

package/dist/assets/services/vendor/squoosh/image-pool.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ImageOutputFormat } from '../../../types.js';
 import type { Operation } from './image.js';
-export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: ImageOutputFormat, quality?: number): Promise<Uint8Array>;
+export declare function processBuffer(buffer: Uint8Array, operations: Operation[], encoding: ImageOutputFormat, quality?: number): Promise<Uint8Array>;

package/dist/assets/types.d.ts

@@ -5,15 +5,19 @@ export type ImageQualityPreset = 'low' | 'mid' | 'high' | 'max' | (string & {});
 export type ImageQuality = ImageQualityPreset | number;
 export type ImageInputFormat = (typeof VALID_INPUT_FORMATS)[number];
 export type ImageOutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
-export type AssetsGlobalStaticImagesList = Map<string, Map<string, {
-    finalPath: string;
-    transform: ImageTransform;
-}>>;
+export type AssetsGlobalStaticImagesList = Map<string, {
+    originalSrcPath: string;
+    transforms: Map<string, {
+        finalPath: string;
+        transform: ImageTransform;
+    }>;
+}>;
 declare global {
     var astroAsset: {
         imageService?: ImageService;
-        addStaticImage?: ((options: ImageTransform) => string) | undefined;
+        addStaticImage?: ((options: ImageTransform, hashProperties: string[]) => string) | undefined;
         staticImages?: AssetsGlobalStaticImagesList;
+        referencedImages?: Set<string>;
     };
 }
 /**
@@ -26,11 +30,17 @@ export interface ImageMetadata {
     format: ImageInputFormat;
     orientation?: number;
 }
-export interface SrcSetValue {
-    url: string;
+/**
+ * A yet to be completed with an url `SrcSetValue`. Other hooks will only see a resolved value, where the URL of the image has been added.
+ */
+export type UnresolvedSrcSetValue = {
+    transform: ImageTransform;
     descriptor?: string;
-    attributes?: Record<string, string>;
-}
+    attributes?: Record<string, any>;
+};
+export type SrcSetValue = UnresolvedSrcSetValue & {
+    url: string;
+};
 /**
  * A yet to be resolved image transform. Used by `getImage`
  */

package/dist/assets/utils/emitAsset.js

@@ -19,6 +19,11 @@ async function emitESMImage(id, watchMode, fileEmitter) {
     src: "",
     ...fileMetadata
   };
+  Object.defineProperty(emittedImage, "fsPath", {
+    enumerable: false,
+    writable: false,
+    value: url
+  });
   if (!watchMode) {
     const pathname = decodeURI(url.pathname);
     const filename = path.basename(pathname, path.extname(pathname) + `.${fileMetadata.format}`);

package/dist/assets/utils/metadata.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ImageMetadata } from '../types.js';
-export declare function imageMetadata(data: Buffer, src?: string): Promise<Omit<ImageMetadata, 'src'>>;
+export declare function imageMetadata(data: Uint8Array, src?: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

package/dist/assets/utils/proxy.d.ts

@@ -0,0 +1 @@
+export declare function getProxyCode(options: Record<string, any>, isSSR: boolean): string;

package/dist/assets/utils/proxy.js

@@ -0,0 +1,16 @@
+function getProxyCode(options, isSSR) {
+  return `
+						new Proxy(${JSON.stringify(options)}, {
+						get(target, name, receiver) {
+							if (name === 'clone') {
+								return structuredClone(target);
+							}
+							${!isSSR ? "globalThis.astroAsset.referencedImages.add(target.fsPath);" : ""}
+							return target[name];
+						}
+					})
+					`;
+}
+export {
+  getProxyCode
+};

package/dist/assets/utils/queryParams.d.ts

@@ -1,2 +1,2 @@
 import type { ImageMetadata } from '../types.js';
-export declare function getOrigQueryParams(params: URLSearchParams): Omit<ImageMetadata, 'src'> | undefined;
+export declare function getOrigQueryParams(params: URLSearchParams): Pick<ImageMetadata, 'width' | 'height' | 'format'> | undefined;

package/dist/assets/utils/transformToPath.d.ts

@@ -1,3 +1,3 @@
 import type { ImageTransform } from '../types.js';
 export declare function propsToFilename(transform: ImageTransform, hash: string): string;
-export declare function hashTransform(transform: ImageTransform, imageService: string): string;
+export declare function hashTransform(transform: ImageTransform, imageService: string, propertiesToHash: string[]): string;

package/dist/assets/utils/transformToPath.js

@@ -12,9 +12,14 @@ function propsToFilename(transform, hash) {
   let outputExt = transform.format ? `.${transform.format}` : ext;
   return `/${filename}_${hash}${outputExt}`;
 }
-function hashTransform(transform, imageService) {
-  const { alt, class: className, style, widths, densities, ...rest } = transform;
-  const hashFields = { ...rest, imageService };
+function hashTransform(transform, imageService, propertiesToHash) {
+  const hashFields = propertiesToHash.reduce(
+    (acc, prop) => {
+      acc[prop] = transform[prop];
+      return acc;
+    },
+    { imageService }
+  );
   return shorthash(deterministicString(hashFields));
 }
 export {