astro 2.1.8 → 2.2.0

package/config.d.ts

@@ -1,4 +1,5 @@
 type ViteUserConfig = import('vite').UserConfig;
+type ViteUserConfigFn = import('vite').UserConfigFn;
 type AstroUserConfig = import('./dist/@types/astro.js').AstroUserConfig;
 
 /**
@@ -10,4 +11,4 @@ export function defineConfig(config: AstroUserConfig): AstroUserConfig;
 /**
  * Use Astro to generate a fully resolved Vite config
  */
-export function getViteConfig(config: ViteUserConfig): ViteUserConfig;
+export function getViteConfig(config: ViteUserConfig): ViteUserConfigFn;

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

@@ -18,8 +18,8 @@ import type { LogOptions } from '../core/logger/core';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server';
 import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
 export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';
-export type { ExternalImageService, LocalImageService } from '../assets/services/service';
-export type { ImageMetadata, ImageTransform } from '../assets/types';
+export type { ExternalImageService, ImageService, LocalImageService, } from '../assets/services/service';
+export type { GetImageResult, ImageInputFormat, ImageMetadata, ImageOutputFormat, ImageQuality, ImageQualityPreset, ImageTransform, } from '../assets/types';
 export type { SSRManifest } from '../core/app/types';
 export type { AstroCookies } from '../core/cookies';
 export interface AstroBuiltinProps {
@@ -568,6 +568,29 @@ export interface AstroUserConfig {
          * ```
          */
         assets?: string;
+        /**
+         * @docs
+         * @name build.assetsPrefix
+         * @type {string}
+         * @default `undefined`
+         * @version 2.2.0
+         * @description
+         * Specifies the prefix for Astro-generated asset links. This can be used if assets are served from a different domain than the current site.
+         *
+         * For example, if this is set to `https://cdn.example.com`, assets will be fetched from `https://cdn.example.com/_astro/...` (regardless of the `base` option).
+         * You would need to upload the files in `./dist/_astro/` to `https://cdn.example.com/_astro/` to serve the assets.
+         * The process varies depending on how the third-party domain is hosted.
+         * To rename the `_astro` path, specify a new directory in `build.assets`.
+         *
+         * ```js
+         * {
+         *   build: {
+         *     assetsPrefix: 'https://cdn.example.com'
+         *   }
+         * }
+         * ```
+         */
+        assetsPrefix?: string;
         /**
          * @docs
          * @name build.serverEntry
@@ -1086,11 +1109,13 @@ export type GetStaticPaths = (options: GetStaticPathsOptions) => Promise<GetStat
  *
  * @example
  * ```ts
- * export async function getStaticPaths() {
+ * import type { GetStaticPaths } from 'astro';
+ *
+ * export const getStaticPaths = (() => {
  *   return results.map((entry) => ({
  *     params: { slug: entry.slug },
  *   }));
- * }
+ * }) satisfies GetStaticPaths;
  *
  * type Params = InferGetStaticParamsType<typeof getStaticPaths>;
  * //   ^? { slug: string; }
@@ -1098,7 +1123,7 @@ export type GetStaticPaths = (options: GetStaticPathsOptions) => Promise<GetStat
  * const { slug } = Astro.params as Params;
  * ```
  */
-export type InferGetStaticParamsType<T> = T extends () => Promise<infer R> ? R extends Array<infer U> ? U extends {
+export type InferGetStaticParamsType<T> = T extends () => infer R | Promise<infer R> ? R extends Array<infer U> ? U extends {
     params: infer P;
 } ? P : never : never : never;
 /**
@@ -1106,7 +1131,9 @@ export type InferGetStaticParamsType<T> = T extends () => Promise<infer R> ? R e
  *
  * @example
  * ```ts
- * export async function getStaticPaths() {
+ * import type { GetStaticPaths } from 'astro';
+ *
+ * export const getStaticPaths = (() => {
  *   return results.map((entry) => ({
  *     params: { slug: entry.slug },
  *     props: {
@@ -1114,15 +1141,15 @@ export type InferGetStaticParamsType<T> = T extends () => Promise<infer R> ? R e
  *       propB: 42
  *     },
  *   }));
- * }
+ * }) satisfies GetStaticPaths;
  *
  * type Props = InferGetStaticPropsType<typeof getStaticPaths>;
  * //   ^? { propA: boolean; propB: number; }
  *
- * const { propA, propB } = Astro.props as Props;
+ * const { propA, propB } = Astro.props;
  * ```
  */
-export type InferGetStaticPropsType<T> = T extends () => Promise<infer R> ? R extends Array<infer U> ? U extends {
+export type InferGetStaticPropsType<T> = T extends () => infer R | Promise<infer R> ? R extends Array<infer U> ? U extends {
     props: infer P;
 } ? P : never : never : never;
 export interface HydrateOptions {

package/dist/assets/image-endpoint.js

@@ -1,4 +1,4 @@
-import mime from "mime";
+import mime from "mime/lite.js";
 import { isRemotePath } from "../core/path.js";
 import { getConfiguredImageService } from "./internal.js";
 import { isLocalService } from "./services/service.js";
@@ -35,7 +35,7 @@ const get = async ({ request }) => {
     return new Response(data, {
       status: 200,
       headers: {
-        "Content-Type": mime.getType(format) || "",
+        "Content-Type": mime.getType(format) ?? `image/${format}`,
         "Cache-Control": "public, max-age=31536000",
         ETag: etag(data.toString()),
         Date: (/* @__PURE__ */ new Date()).toUTCString()

package/dist/assets/index.d.ts

@@ -1,5 +1,5 @@
 export { getConfiguredImageService, getImage } from './internal.js';
-export { baseService } from './services/service.js';
+export { baseService, isLocalService } from './services/service.js';
 export { type LocalImageProps, type RemoteImageProps } from './types.js';
 export { emitESMImage } from './utils/emitAsset.js';
 export { imageMetadata } from './utils/metadata.js';

package/dist/assets/index.js

@@ -1,5 +1,5 @@
 import { getConfiguredImageService, getImage } from "./internal.js";
-import { baseService } from "./services/service.js";
+import { baseService, isLocalService } from "./services/service.js";
 import {} from "./types.js";
 import { emitESMImage } from "./utils/emitAsset.js";
 import { imageMetadata } from "./utils/metadata.js";
@@ -8,5 +8,6 @@ export {
   emitESMImage,
   getConfiguredImageService,
   getImage,
-  imageMetadata
+  imageMetadata,
+  isLocalService
 };

package/dist/assets/internal.d.ts

@@ -1,14 +1,8 @@
 import type { StaticBuildOptions } from '../core/build/types.js';
 import { type ImageService } from './services/service.js';
-import type { ImageMetadata, ImageTransform } from './types.js';
+import type { GetImageResult, ImageMetadata, ImageTransform } from './types.js';
 export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
 export declare function getConfiguredImageService(): Promise<ImageService>;
-interface GetImageResult {
-    rawOptions: ImageTransform;
-    options: ImageTransform;
-    src: string;
-    attributes: Record<string, any>;
-}
 /**
  * Get an optimized image and the necessary attributes to render it.
  *
@@ -18,7 +12,7 @@ interface GetImageResult {
  * import { getImage } from 'astro:assets';
  * import originalImage from '../assets/image.png';
  *
- * const optimizedImage = await getImage({src: originalImage, width: 1280 })
+ * const optimizedImage = await getImage({src: originalImage, width: 1280 });
  * ---
  * <img src={optimizedImage.src} {...optimizedImage.attributes} />
  * ```
@@ -26,7 +20,13 @@ interface GetImageResult {
  * This is functionally equivalent to using the `<Image />` component, as the component calls this function internally.
  */
 export declare function getImage(options: ImageTransform): Promise<GetImageResult>;
-export declare function getStaticImageList(): Iterable<[ImageTransform, string]>;
+export declare function getStaticImageList(): Iterable<[
+    string,
+    {
+        path: string;
+        options: ImageTransform;
+    }
+]>;
 interface GenerationData {
     weight: {
         before: number;

package/dist/assets/internal.js

@@ -7,7 +7,8 @@ function isESMImportedImage(src) {
   return typeof src === "object";
 }
 async function getConfiguredImageService() {
-  if (!globalThis.astroAsset.imageService) {
+  var _a;
+  if (!((_a = globalThis == null ? void 0 : globalThis.astroAsset) == null ? void 0 : _a.imageService)) {
     const { default: service } = await import(
       // @ts-expect-error
       "virtual:image-service"
@@ -16,12 +17,20 @@ async function getConfiguredImageService() {
       error.cause = e;
       throw error;
     });
+    if (!globalThis.astroAsset)
+      globalThis.astroAsset = {};
     globalThis.astroAsset.imageService = service;
     return service;
   }
   return globalThis.astroAsset.imageService;
 }
 async function getImage(options) {
+  if (!options || typeof options !== "object") {
+    throw new AstroError({
+      ...AstroErrorData.ExpectedImageOptions,
+      message: AstroErrorData.ExpectedImageOptions.message(JSON.stringify(options))
+    });
+  }
   const service = await getConfiguredImageService();
   const validatedOptions = service.validateOptions ? service.validateOptions(options) : options;
   let imageURL = service.getURL(validatedOptions);

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { ImageTransform, OutputFormat } from '../types.js';
+import type { ImageOutputFormat, ImageTransform } 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;
@@ -48,7 +48,7 @@ export interface LocalImageService extends SharedServiceProps {
      */
     transform: (inputBuffer: Buffer, transform: LocalImageTransform) => Promise<{
         data: Buffer;
-        format: OutputFormat;
+        format: ImageOutputFormat;
     }>;
 }
 export type BaseServiceTransform = {

package/dist/assets/services/service.js

@@ -16,6 +16,12 @@ function parseQuality(quality) {
 }
 const baseService = {
   validateOptions(options) {
+    if (!options.src || typeof options.src !== "string" && typeof options.src !== "object") {
+      throw new AstroError({
+        ...AstroErrorData.ExpectedImage,
+        message: AstroErrorData.ExpectedImage.message(JSON.stringify(options.src))
+      });
+    }
     if (!isESMImportedImage(options.src)) {
       let missingDimension;
       if (!options.width && !options.height) {

package/dist/assets/services/vendor/squoosh/copy-wasm.d.ts

@@ -1 +1,2 @@
 export declare function copyWasmFiles(dir: URL): Promise<void>;
+export declare function deleteWasmFiles(dir: URL): Promise<void>;

package/dist/assets/services/vendor/squoosh/copy-wasm.js

@@ -3,22 +3,35 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 async function copyWasmFiles(dir) {
   const src = new URL("./", import.meta.url);
-  await copyDir(fileURLToPath(src), fileURLToPath(dir));
+  const fileList = await listFiles(fileURLToPath(src), fileURLToPath(dir));
+  for (let file of fileList) {
+    await fs.mkdir(path.dirname(file.dest), { recursive: true });
+    await fs.copyFile(file.src, file.dest);
+  }
 }
-async function copyDir(src, dest) {
+async function deleteWasmFiles(dir) {
+  const src = new URL("./", import.meta.url);
+  const fileList = await listFiles(fileURLToPath(src), fileURLToPath(dir));
+  for (let file of fileList) {
+    await fs.rm(file.dest);
+  }
+}
+async function listFiles(src, dest) {
   const itemNames = await fs.readdir(src);
+  const copiedFiles = [];
   await Promise.all(itemNames.map(async (srcName) => {
     const srcPath = path.join(src, srcName);
     const destPath = path.join(dest, srcName);
     const s = await fs.stat(srcPath);
     if (s.isFile() && /.wasm$/.test(srcPath)) {
-      await fs.mkdir(path.dirname(destPath), { recursive: true });
-      await fs.copyFile(srcPath, destPath);
+      copiedFiles.push({ src: srcPath, dest: destPath });
     } else if (s.isDirectory()) {
-      await copyDir(srcPath, destPath);
+      copiedFiles.push(...await listFiles(srcPath, destPath));
     }
   }));
+  return copiedFiles;
 }
 export {
-  copyWasmFiles
+  copyWasmFiles,
+  deleteWasmFiles
 };

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

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

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { OutputFormat } from '../../../types.js';
+import type { ImageOutputFormat } from '../../../types.js';
 type RotateOperation = {
     type: 'rotate';
     numRotations: number;
@@ -10,5 +10,5 @@ type ResizeOperation = {
     height?: number;
 };
 export type Operation = RotateOperation | ResizeOperation;
-export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: OutputFormat, quality?: number): Promise<Uint8Array>;
+export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: ImageOutputFormat, quality?: number): Promise<Uint8Array>;
 export {};

package/dist/assets/types.d.ts

@@ -2,13 +2,16 @@ import type { VALID_INPUT_FORMATS, VALID_OUTPUT_FORMATS } from './consts.js';
 import type { ImageService } from './services/service.js';
 export type ImageQualityPreset = 'low' | 'mid' | 'high' | 'max' | (string & {});
 export type ImageQuality = ImageQualityPreset | number;
-export type InputFormat = (typeof VALID_INPUT_FORMATS)[number] | 'svg';
-export type OutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
+export type ImageInputFormat = (typeof VALID_INPUT_FORMATS)[number] | 'svg';
+export type ImageOutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
 declare global {
     var astroAsset: {
         imageService?: ImageService;
         addStaticImage?: ((options: ImageTransform) => string) | undefined;
-        staticImages?: Map<ImageTransform, string>;
+        staticImages?: Map<string, {
+            path: string;
+            options: ImageTransform;
+        }>;
     };
 }
 /**
@@ -18,19 +21,25 @@ export interface ImageMetadata {
     src: string;
     width: number;
     height: number;
-    format: InputFormat;
+    format: ImageInputFormat;
 }
 /**
  * Options accepted by the image transformation service.
  */
 export type ImageTransform = {
     src: ImageMetadata | string;
-    width?: number;
-    height?: number;
-    quality?: ImageQuality;
-    format?: OutputFormat;
+    width?: number | undefined;
+    height?: number | undefined;
+    quality?: ImageQuality | undefined;
+    format?: ImageOutputFormat | undefined;
     [key: string]: any;
 };
+export interface GetImageResult {
+    rawOptions: ImageTransform;
+    options: ImageTransform;
+    src: string;
+    attributes: Record<string, any>;
+}
 type WithRequired<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };
@@ -88,11 +97,11 @@ export type LocalImageProps<T> = ImageSharedProps<T> & {
      * <Image src={...} format="avif" alt="..." />
      * ```
      */
-    format?: OutputFormat;
+    format?: ImageOutputFormat;
     /**
      * Desired quality for the image. Value can either be a preset such as `low` or `high`, or a numeric value from 0 to 100.
      *
-     * The perceptual quality of the output image is loader-specific.
+     * The perceptual quality of the output image is service-specific.
      * For instance, a certain service might decide that `high` results in a very beautiful image, but another could choose for it to be at best passable.
      *
      * **Example**:

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

@@ -1,3 +1,4 @@
 import type { AstroSettings } from '../../@types/astro';
-export declare function emitESMImage(id: string, watchMode: boolean, fileEmitter: any, settings: Pick<AstroSettings, 'config'>): Promise<import("./metadata.js").Metadata | undefined>;
+import { type Metadata } from './metadata.js';
+export declare function emitESMImage(id: string | undefined, watchMode: boolean, fileEmitter: any, settings: Pick<AstroSettings, 'config'>): Promise<Metadata | undefined>;
 export declare function emoji(char: string, fallback: string): string;

package/dist/assets/utils/emitAsset.js

@@ -4,10 +4,13 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import slash from "slash";
 import { imageMetadata } from "./metadata.js";
 async function emitESMImage(id, watchMode, fileEmitter, settings) {
+  if (!id) {
+    return void 0;
+  }
   const url = pathToFileURL(id);
   const meta = await imageMetadata(url);
   if (!meta) {
-    return;
+    return void 0;
   }
   if (!watchMode) {
     const pathname = decodeURI(url.pathname);

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

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

package/dist/assets/utils/transformToPath.js

@@ -2,18 +2,22 @@ import { basename, extname } from "path";
 import { removeQueryString } from "../../core/path.js";
 import { shorthash } from "../../runtime/server/shorthash.js";
 import { isESMImportedImage } from "../internal.js";
-function propsToFilename(transform, imageService) {
+function propsToFilename(transform, hash) {
   if (!isESMImportedImage(transform.src)) {
     return transform.src;
   }
   let filename = removeQueryString(transform.src.src);
   const ext = extname(filename);
   filename = basename(filename, ext);
+  const outputExt = transform.format ? `.${transform.format}` : ext;
+  return `/${filename}_${hash}${outputExt}`;
+}
+function hashTransform(transform, imageService) {
   const { alt, ...rest } = transform;
   const hashFields = { ...rest, imageService };
-  const outputExt = transform.format ? `.${transform.format}` : ext;
-  return `/${filename}_${shorthash(JSON.stringify(hashFields))}${outputExt}`;
+  return shorthash(JSON.stringify(hashFields));
 }
 export {
+  hashTransform,
   propsToFilename
 };

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

@@ -1,12 +1,12 @@
 import { bold } from "kleur/colors";
 import MagicString from "magic-string";
-import mime from "mime";
+import mime from "mime/lite.js";
 import fs from "node:fs/promises";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { normalizePath } from "vite";
 import { error } from "../core/logger/core.js";
-import { joinPaths, prependForwardSlash } from "../core/path.js";
+import { appendForwardSlash, joinPaths, prependForwardSlash } from "../core/path.js";
 import { VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { isESMImportedImage } from "./internal.js";
 import { isLocalService } from "./services/service.js";
@@ -14,7 +14,7 @@ import { copyWasmFiles } from "./services/vendor/squoosh/copy-wasm.js";
 import { emitESMImage } from "./utils/emitAsset.js";
 import { imageMetadata } from "./utils/metadata.js";
 import { getOrigQueryParams } from "./utils/queryParams.js";
-import { propsToFilename } from "./utils/transformToPath.js";
+import { hashTransform, propsToFilename } from "./utils/transformToPath.js";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
 function assets({
   settings,
@@ -69,7 +69,7 @@ function assets({
       load(id) {
         if (id === resolvedVirtualModuleId) {
           return `
-					export { getImage, getConfiguredImageService } from "astro/assets";
+					export { getImage, getConfiguredImageService, isLocalService } from "astro/assets";
 					export { default as Image } from "astro/components/Image.astro";
 				`;
         }
@@ -107,10 +107,7 @@ function assets({
               data = result.data;
               format = result.format;
             }
-            res.setHeader(
-              "Content-Type",
-              mime.getType(fileURLToPath(filePathURL)) || `image/${format}`
-            );
+            res.setHeader("Content-Type", mime.getType(format) ?? `image/${format}`);
             res.setHeader("Cache-Control", "max-age=360000");
             const stream = Readable.from(data);
             return stream.pipe(res);
@@ -126,30 +123,34 @@ function assets({
           if (!globalThis.astroAsset.staticImages) {
             globalThis.astroAsset.staticImages = /* @__PURE__ */ new Map();
           }
+          const hash = hashTransform(options, settings.config.image.service);
           let filePath;
-          if (globalThis.astroAsset.staticImages.has(options)) {
-            filePath = globalThis.astroAsset.staticImages.get(options);
+          if (globalThis.astroAsset.staticImages.has(hash)) {
+            filePath = globalThis.astroAsset.staticImages.get(hash).path;
           } else {
             if (!isESMImportedImage(options.src)) {
               return options.src;
             }
             filePath = prependForwardSlash(
-              joinPaths(
-                settings.config.build.assets,
-                propsToFilename(options, settings.config.image.service)
-              )
+              joinPaths(settings.config.build.assets, propsToFilename(options, hash))
             );
-            globalThis.astroAsset.staticImages.set(options, filePath);
+            globalThis.astroAsset.staticImages.set(hash, { path: filePath, options });
+          }
+          if (settings.config.build.assetsPrefix) {
+            return joinPaths(settings.config.build.assetsPrefix, filePath);
+          } else {
+            return prependForwardSlash(joinPaths(settings.config.base, filePath));
           }
-          return prependForwardSlash(joinPaths(settings.config.base, filePath));
         };
       },
       async buildEnd() {
         if (mode != "build") {
           return;
         }
-        const dir = settings.config.output === "server" ? settings.config.build.server : settings.config.outDir;
-        await copyWasmFiles(new URL("./chunks", dir));
+        if (settings.config.image.service === "astro/assets/services/squoosh") {
+          const dir = settings.config.output === "server" ? settings.config.build.server : settings.config.outDir;
+          await copyWasmFiles(new URL("./chunks", dir));
+        }
       },
       // In build, rewrite paths to ESM imported images in code to their final location
       async renderChunk(code) {
@@ -160,7 +161,8 @@ function assets({
           s = s || (s = new MagicString(code));
           const [full, hash, postfix = ""] = match;
           const file = this.getFileName(hash);
-          const outputFilepath = normalizePath(resolvedConfig.base + file + postfix);
+          const prefix = settings.config.build.assetsPrefix ? appendForwardSlash(settings.config.build.assetsPrefix) : resolvedConfig.base;
+          const outputFilepath = prefix + normalizePath(file + postfix);
           s.overwrite(match.index, match.index + full.length, outputFilepath);
         }
         if (s) {

package/dist/cli/index.js

@@ -16,7 +16,6 @@ import { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js
 import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
 import * as event from "../events/index.js";
 import { eventConfigError, eventError, telemetry } from "../events/index.js";
-import { check } from "./check/index.js";
 import { openInBrowser } from "./open.js";
 function printAstroHelp() {
   printHelp({
@@ -174,6 +173,7 @@ async function runCommand(cmd, flags) {
       });
     }
     case "check": {
+      const { check } = await import("./check/index.js");
       const checkServer = await check(settings, { flags, logging });
       if (checkServer) {
         if (checkServer.isWatchMode) {

package/dist/content/runtime-assets.d.ts

@@ -1,8 +1,4 @@
+import type { PluginContext } from 'rollup';
 import { z } from 'zod';
-import { type Metadata } from '../assets/utils/metadata.js';
-export declare function createImage(options: {
-    assetsDir: string;
-    relAssetsDir: string;
-}): () => z.ZodEffects<z.ZodString, (Metadata & {
-    __astro_asset: true;
-}) | undefined, string>;
+import type { AstroSettings } from '../@types/astro.js';
+export declare function createImage(settings: AstroSettings, pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/utils/metadata.js").Metadata, string>;

package/dist/content/runtime-assets.js

@@ -1,24 +1,28 @@
-import { pathToFileURL } from "url";
 import { z } from "zod";
-import { imageMetadata } from "../assets/utils/metadata.js";
-function createImage(options) {
+import { emitESMImage } from "../assets/index.js";
+function createImage(settings, pluginContext, entryFilePath) {
   return () => {
-    if (options.assetsDir === "undefined") {
-      throw new Error("Enable `experimental.assets` in your Astro config to use image()");
-    }
-    return z.string({ description: "__image" }).transform(async (imagePath) => {
-      return await getImageMetadata(pathToFileURL(imagePath));
+    return z.string().transform(async (imagePath, ctx) => {
+      var _a;
+      const resolvedFilePath = (_a = await pluginContext.resolve(imagePath, entryFilePath)) == null ? void 0 : _a.id;
+      const metadata = await emitESMImage(
+        resolvedFilePath,
+        pluginContext.meta.watchMode,
+        pluginContext.emitFile,
+        settings
+      );
+      if (!metadata) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Image ${imagePath} does not exist. Is the path correct?`,
+          fatal: true
+        });
+        return z.NEVER;
+      }
+      return metadata;
     });
   };
 }
-async function getImageMetadata(imagePath) {
-  const meta = await imageMetadata(imagePath);
-  if (!meta) {
-    return void 0;
-  }
-  delete meta.orientation;
-  return { ...meta, __astro_asset: true };
-}
 export {
   createImage
 };

package/dist/content/template/virtual-mod.d.mts

@@ -1,3 +1,4 @@
 export function defineCollection(config: any): any;
+export function image(): never;
 export const getCollection: any;
 export const getEntryBySlug: any;

package/dist/content/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import matter from 'gray-matter';
 import fsMod from 'node:fs';
-import type { EmitFile, PluginContext } from 'rollup';
+import type { PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings } from '../@types/astro.js';
@@ -47,17 +47,13 @@ export type EntryInfo = {
 export declare const msg: {
     collectionConfigMissing: (collection: string) => string;
 };
-/**
- * Mutate (arf) the entryData to reroute assets to their final paths
- */
-export declare function patchAssets(frontmatterEntry: Record<string, any>, watchMode: boolean, fileEmitter: EmitFile, astroSettings: AstroSettings): Promise<void>;
 export declare function getEntrySlug({ id, collection, slug, unvalidatedSlug, }: EntryInfo & {
     unvalidatedSlug?: unknown;
 }): string;
 export declare function getEntryData(entry: EntryInfo & {
     unvalidatedData: Record<string, unknown>;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig, resolver: (idToResolve: string) => ReturnType<PluginContext['resolve']>): Promise<{
+}, collectionConfig: CollectionConfig, pluginContext: PluginContext, settings: AstroSettings): Promise<{
     [x: string]: unknown;
 }>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];