astro 2.1.3 → 2.1.5

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

@@ -5,6 +5,7 @@ import type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, Rehype
 import type * as babel from '@babel/core';
 import type { OutgoingHttpHeaders } from 'http';
 import type { AddressInfo } from 'net';
+import type * as rollup from 'rollup';
 import type { TsConfigJson } from 'tsconfig-resolver';
 import type * as vite from 'vite';
 import type { z } from 'zod';
@@ -956,12 +957,26 @@ export interface InjectedRoute {
 export interface AstroConfig extends z.output<typeof AstroConfigSchema> {
     integrations: AstroIntegration[];
 }
+export type ContentEntryModule = {
+    id: string;
+    collection: string;
+    slug: string;
+    body: string;
+    data: Record<string, unknown>;
+    _internal: {
+        rawData: string;
+        filePath: string;
+    };
+};
 export interface ContentEntryType {
     extensions: string[];
     getEntryInfo(params: {
         fileUrl: URL;
         contents: string;
     }): GetEntryInfoReturnType | Promise<GetEntryInfoReturnType>;
+    getRenderModule?(params: {
+        entry: ContentEntryModule;
+    }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
 }
 type GetEntryInfoReturnType = {

package/dist/@types/typed-emitter.d.ts

@@ -22,7 +22,7 @@ export type EventMap = {
  * myEmitter.emit("error", "x")  // <- Will catch this type error;
  * ```
  */
-interface TypedEventEmitter<Events extends EventMap> {
+export interface TypedEventEmitter<Events extends EventMap> {
     addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
     on<E extends keyof Events>(event: E, listener: Events[E]): this;
     once<E extends keyof Events>(event: E, listener: Events[E]): this;
@@ -39,4 +39,3 @@ interface TypedEventEmitter<Events extends EventMap> {
     getMaxListeners(): number;
     setMaxListeners(maxListeners: number): this;
 }
-export default TypedEventEmitter;

package/dist/assets/consts.js

@@ -1,6 +1,14 @@
 const VIRTUAL_MODULE_ID = "astro:assets";
 const VIRTUAL_SERVICE_ID = "virtual:image-service";
 const VALID_INPUT_FORMATS = [
+  // TODO: `image-size` does not support the following formats, so users can't import them.
+  // However, it would be immensely useful to add, for three reasons:
+  // - `heic` and `heif` are common formats, especially among Apple users.
+  // - AVIF is a common format on the web that's bound to become more and more common.
+  // - It's totally reasonable for an user's provided image service to want to support more image types.
+  //'heic',
+  //'heif',
+  //'avif',
   "jpeg",
   "jpg",
   "png",

package/dist/assets/image-endpoint.js

@@ -38,7 +38,7 @@ const get = async ({ request }) => {
         "Content-Type": mime.getType(format) || "",
         "Cache-Control": "public, max-age=31536000",
         ETag: etag(data.toString()),
-        Date: new Date().toUTCString()
+        Date: (/* @__PURE__ */ new Date()).toUTCString()
       }
     });
   } catch (err) {

package/dist/assets/internal.d.ts

@@ -1,9 +1,10 @@
 import type { StaticBuildOptions } from '../core/build/types.js';
-import { ImageService } from './services/service.js';
+import { type ImageService } from './services/service.js';
 import type { 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>;

package/dist/assets/internal.js

@@ -6,7 +6,10 @@ function isESMImportedImage(src) {
 }
 async function getConfiguredImageService() {
   if (!globalThis.astroAsset.imageService) {
-    const { default: service } = await import("virtual:image-service").catch((e) => {
+    const { default: service } = await import(
+      // @ts-expect-error
+      "virtual:image-service"
+    ).catch((e) => {
       const error = new AstroError(AstroErrorData.InvalidImageService);
       error.cause = e;
       throw error;
@@ -18,14 +21,16 @@ async function getConfiguredImageService() {
 }
 async function getImage(options) {
   const service = await getConfiguredImageService();
-  let imageURL = service.getURL(options);
+  const validatedOptions = service.validateOptions ? service.validateOptions(options) : options;
+  let imageURL = service.getURL(validatedOptions);
   if (isLocalService(service) && globalThis.astroAsset.addStaticImage) {
-    imageURL = globalThis.astroAsset.addStaticImage(options);
+    imageURL = globalThis.astroAsset.addStaticImage(validatedOptions);
   }
   return {
-    options,
+    rawOptions: options,
+    options: validatedOptions,
     src: imageURL,
-    attributes: service.getHTMLAttributes !== void 0 ? service.getHTMLAttributes(options) : {}
+    attributes: service.getHTMLAttributes !== void 0 ? service.getHTMLAttributes(validatedOptions) : {}
   };
 }
 function getStaticImageList() {

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

@@ -20,6 +20,15 @@ interface SharedServiceProps {
      * In most cases, you'll want to return directly what your user supplied you, minus the attributes that were used to generate the image.
      */
     getHTMLAttributes?: (options: ImageTransform) => Record<string, any>;
+    /**
+     * Validate and return the options passed by the user.
+     *
+     * This method is useful to present errors to users who have entered invalid options.
+     * For instance, if they are missing a required property or have entered an invalid image format.
+     *
+     * This method should returns options, and can be used to set defaults (ex: a default output format to be used if the user didn't specify one.)
+     */
+    validateOptions?: (options: ImageTransform) => ImageTransform;
 }
 export type ExternalImageService = SharedServiceProps;
 type LocalImageTransform = {
@@ -46,7 +55,7 @@ export type BaseServiceTransform = {
     src: string;
     width?: number;
     height?: number;
-    format?: string | null;
+    format: string;
     quality?: string | null;
 };
 /**

package/dist/assets/services/service.js

@@ -1,5 +1,4 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-import { isRemotePath } from "../../core/path.js";
 import { VALID_INPUT_FORMATS } from "../consts.js";
 import { isESMImportedImage } from "../internal.js";
 function isLocalService(service) {
@@ -16,6 +15,39 @@ function parseQuality(quality) {
   return result;
 }
 const baseService = {
+  validateOptions(options) {
+    if (!isESMImportedImage(options.src)) {
+      let missingDimension;
+      if (!options.width && !options.height) {
+        missingDimension = "both";
+      } else if (!options.width && options.height) {
+        missingDimension = "width";
+      } else if (options.width && !options.height) {
+        missingDimension = "height";
+      }
+      if (missingDimension) {
+        throw new AstroError({
+          ...AstroErrorData.MissingImageDimension,
+          message: AstroErrorData.MissingImageDimension.message(missingDimension, options.src)
+        });
+      }
+    } else {
+      if (!VALID_INPUT_FORMATS.includes(options.src.format)) {
+        throw new AstroError({
+          ...AstroErrorData.UnsupportedImageFormat,
+          message: AstroErrorData.UnsupportedImageFormat.message(
+            options.src.format,
+            options.src.src,
+            VALID_INPUT_FORMATS
+          )
+        });
+      }
+    }
+    if (!options.format) {
+      options.format = "webp";
+    }
+    return options;
+  },
   getHTMLAttributes(options) {
     let targetWidth = options.width;
     let targetHeight = options.height;
@@ -25,7 +57,7 @@ const baseService = {
         targetWidth = Math.round(targetHeight * aspectRatio);
       } else if (targetWidth && !targetHeight) {
         targetHeight = Math.round(targetWidth / aspectRatio);
-      } else {
+      } else if (!targetWidth && !targetHeight) {
         targetWidth = options.src.width;
         targetHeight = options.src.height;
       }
@@ -41,36 +73,10 @@ const baseService = {
   },
   getURL(options) {
     if (!isESMImportedImage(options.src)) {
-      let missingDimension;
-      if (!options.width && !options.height) {
-        missingDimension = "both";
-      } else if (!options.width && options.height) {
-        missingDimension = "width";
-      } else if (options.width && !options.height) {
-        missingDimension = "height";
-      }
-      if (missingDimension) {
-        throw new AstroError({
-          ...AstroErrorData.MissingImageDimension,
-          message: AstroErrorData.MissingImageDimension.message(missingDimension, options.src)
-        });
-      }
-    }
-    if (!isESMImportedImage(options.src) && isRemotePath(options.src)) {
       return options.src;
     }
-    if (isESMImportedImage(options.src) && !VALID_INPUT_FORMATS.includes(options.src.format)) {
-      throw new AstroError({
-        ...AstroErrorData.UnsupportedImageFormat,
-        message: AstroErrorData.UnsupportedImageFormat.message(
-          options.src.format,
-          options.src.src,
-          VALID_INPUT_FORMATS
-        )
-      });
-    }
     const searchParams = new URLSearchParams();
-    searchParams.append("href", isESMImportedImage(options.src) ? options.src.src : options.src);
+    searchParams.append("href", options.src.src);
     options.width && searchParams.append("w", options.width.toString());
     options.height && searchParams.append("h", options.height.toString());
     options.quality && searchParams.append("q", options.quality.toString());

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

@@ -1,3 +1,3 @@
-import { LocalImageService } from './service.js';
+import { type LocalImageService } from './service.js';
 declare const sharpService: LocalImageService;
 export default sharpService;

package/dist/assets/services/sharp.js

@@ -1,4 +1,7 @@
-import { baseService, parseQuality } from "./service.js";
+import {
+  baseService,
+  parseQuality
+} from "./service.js";
 let sharp;
 const qualityTable = {
   low: 25,
@@ -16,6 +19,7 @@ async function loadSharp() {
   return sharpImport;
 }
 const sharpService = {
+  validateOptions: baseService.validateOptions,
   getURL: baseService.getURL,
   parseURL: baseService.parseURL,
   getHTMLAttributes: baseService.getHTMLAttributes,
@@ -23,9 +27,6 @@ const sharpService = {
     if (!sharp)
       sharp = await loadSharp();
     const transform = transformOptions;
-    if (!transform.format) {
-      transform.format = "webp";
-    }
     let result = sharp(inputBuffer, { failOnError: false, pages: -1 });
     if (transform.height && !transform.width) {
       result.resize({ height: transform.height });

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

@@ -1,3 +1,3 @@
-import { LocalImageService } from './service.js';
+import { type LocalImageService } from './service.js';
 declare const service: LocalImageService;
 export default service;

package/dist/assets/services/squoosh.js

@@ -1,8 +1,12 @@
-import { baseService, parseQuality } from "./service.js";
+import {
+  baseService,
+  parseQuality
+} from "./service.js";
 import { processBuffer } from "./vendor/squoosh/image-pool.js";
 const baseQuality = { low: 25, mid: 50, high: 80, max: 100 };
 const qualityTable = {
   avif: {
+    // Squoosh's AVIF encoder has a bit of a weird behavior where `62` is technically the maximum, and anything over is overkill
     max: 62,
     high: 45,
     mid: 35,
@@ -11,17 +15,16 @@ const qualityTable = {
   jpeg: baseQuality,
   jpg: baseQuality,
   webp: baseQuality
+  // Squoosh's PNG encoder does not support a quality setting, so we can skip that here
 };
 const service = {
+  validateOptions: baseService.validateOptions,
   getURL: baseService.getURL,
   parseURL: baseService.parseURL,
   getHTMLAttributes: baseService.getHTMLAttributes,
   async transform(inputBuffer, transformOptions) {
     const transform = transformOptions;
     let format = transform.format;
-    if (!format) {
-      format = "webp";
-    }
     const operations = [];
     if (transform.height && !transform.width) {
       operations.push({

package/dist/assets/services/vendor/squoosh/codecs.js

@@ -212,6 +212,7 @@ const codecs = {
   avif: {
     name: "AVIF",
     extension: "avif",
+    // eslint-disable-next-line no-control-regex
     detectors: [/^\x00\x00\x00 ftypavif\x00\x00\x00\x00/],
     dec: () => instantiateEmscriptenWasm(avifDec, avifDecWasm.toString()),
     enc: async () => {
@@ -241,6 +242,7 @@ const codecs = {
   oxipng: {
     name: "OxiPNG",
     extension: "png",
+    // eslint-disable-next-line no-control-regex
     detectors: [/^\x89PNG\x0D\x0A\x1A\x0A/],
     dec: async () => {
       await pngEncDecInit();

package/dist/assets/services/vendor/squoosh/image-pool.js

@@ -7,6 +7,8 @@ import execOnce from "./utils/execOnce.js";
 import WorkerPool from "./utils/workerPool.js";
 const getWorker = execOnce(() => {
   return new WorkerPool(
+    // There will be at most 7 workers needed since each worker will take
+    // at least 1 operation type.
     Math.max(1, Math.min(cpus().length - 1, 7)),
     fileURLToPath(getModuleURL(import.meta.url))
   );

package/dist/assets/services/vendor/squoosh/impl.js

@@ -85,6 +85,8 @@ async function encodeAvif(image, opts) {
   const quality = opts.quality || 75;
   const r = await m.encode(image.data, image.width, image.height, {
     ...e.defaultEncoderOptions,
+    // Think of cqLevel as the "amount" of quantization (0 to 62),
+    // so a lower value yields higher quality (0 to 100).
     cqLevel: quality === 0 ? val : Math.round(val - quality / 100 * val)
   });
   return r;

package/dist/assets/utils/metadata.js

@@ -1,10 +1,7 @@
 import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-let sizeOf;
+import imageSize from "../vendor/image-size/index.js";
 async function imageMetadata(src, data) {
-  if (!sizeOf) {
-    sizeOf = await import("image-size").then((mod) => mod.default);
-  }
   let file = data;
   if (!file) {
     try {
@@ -13,7 +10,7 @@ async function imageMetadata(src, data) {
       return void 0;
     }
   }
-  const { width, height, type, orientation } = await sizeOf(file);
+  const { width, height, type, orientation } = imageSize(file);
   const isPortrait = (orientation || 0) >= 5;
   if (!width || !height || !type) {
     return void 0;

package/dist/assets/vendor/image-size/detector.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { type imageType } from './types.js';
+export declare function detector(buffer: Buffer): imageType | undefined;

package/dist/assets/vendor/image-size/detector.js

@@ -0,0 +1,28 @@
+import { typeHandlers } from "./types.js";
+const keys = Object.keys(typeHandlers);
+const firstBytes = {
+  56: "psd",
+  66: "bmp",
+  68: "dds",
+  71: "gif",
+  73: "tiff",
+  77: "tiff",
+  82: "webp",
+  105: "icns",
+  137: "png",
+  255: "jpg"
+};
+function detector(buffer) {
+  const byte = buffer[0];
+  if (byte in firstBytes) {
+    const type = firstBytes[byte];
+    if (type && typeHandlers[type].validate(buffer)) {
+      return type;
+    }
+  }
+  const finder = (key) => typeHandlers[key].validate(buffer);
+  return keys.find(finder);
+}
+export {
+  detector
+};

package/dist/assets/vendor/image-size/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { type imageType } from "./types.js";
+import type { ISizeCalculationResult } from "./types/interface.js";
+type CallbackFn = (e: Error | null, r?: ISizeCalculationResult) => void;
+export default imageSize;
+export declare function imageSize(input: Buffer | string): ISizeCalculationResult;
+export declare function imageSize(input: string, callback: CallbackFn): void;
+export declare const disableFS: (v: boolean) => void;
+export declare const disableTypes: (types: imageType[]) => void;
+export declare const setConcurrency: (c: number) => void;
+export declare const types: string[];

package/dist/assets/vendor/image-size/index.js

@@ -0,0 +1,93 @@
+import * as fs from "fs";
+import * as path from "path";
+import Queue from "../queue/queue.js";
+import { detector } from "./detector.js";
+import { typeHandlers } from "./types.js";
+const MaxBufferSize = 512 * 1024;
+const queue = new Queue({ concurrency: 100, autostart: true });
+const globalOptions = {
+  disabledFS: false,
+  disabledTypes: []
+};
+function lookup(buffer, filepath) {
+  const type = detector(buffer);
+  if (typeof type !== "undefined") {
+    if (globalOptions.disabledTypes.indexOf(type) > -1) {
+      throw new TypeError("disabled file type: " + type);
+    }
+    if (type in typeHandlers) {
+      const size = typeHandlers[type].calculate(buffer, filepath);
+      if (size !== void 0) {
+        size.type = type;
+        return size;
+      }
+    }
+  }
+  throw new TypeError(
+    "unsupported file type: " + type + " (file: " + filepath + ")"
+  );
+}
+async function asyncFileToBuffer(filepath) {
+  const handle = await fs.promises.open(filepath, "r");
+  const { size } = await handle.stat();
+  if (size <= 0) {
+    await handle.close();
+    throw new Error("Empty file");
+  }
+  const bufferSize = Math.min(size, MaxBufferSize);
+  const buffer = Buffer.alloc(bufferSize);
+  await handle.read(buffer, 0, bufferSize, 0);
+  await handle.close();
+  return buffer;
+}
+function syncFileToBuffer(filepath) {
+  const descriptor = fs.openSync(filepath, "r");
+  const { size } = fs.fstatSync(descriptor);
+  if (size <= 0) {
+    fs.closeSync(descriptor);
+    throw new Error("Empty file");
+  }
+  const bufferSize = Math.min(size, MaxBufferSize);
+  const buffer = Buffer.alloc(bufferSize);
+  fs.readSync(descriptor, buffer, 0, bufferSize, 0);
+  fs.closeSync(descriptor);
+  return buffer;
+}
+var image_size_default = imageSize;
+function imageSize(input, callback) {
+  if (Buffer.isBuffer(input)) {
+    return lookup(input);
+  }
+  if (typeof input !== "string" || globalOptions.disabledFS) {
+    throw new TypeError("invalid invocation. input should be a Buffer");
+  }
+  const filepath = path.resolve(input);
+  if (typeof callback === "function") {
+    queue.push(
+      () => asyncFileToBuffer(filepath).then(
+        (buffer) => process.nextTick(callback, null, lookup(buffer, filepath))
+      ).catch(callback)
+    );
+  } else {
+    const buffer = syncFileToBuffer(filepath);
+    return lookup(buffer, filepath);
+  }
+}
+const disableFS = (v) => {
+  globalOptions.disabledFS = v;
+};
+const disableTypes = (types2) => {
+  globalOptions.disabledTypes = types2;
+};
+const setConcurrency = (c) => {
+  queue.concurrency = c;
+};
+const types = Object.keys(typeHandlers);
+export {
+  image_size_default as default,
+  disableFS,
+  disableTypes,
+  imageSize,
+  setConcurrency,
+  types
+};

package/dist/assets/vendor/image-size/readUInt.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+type Bits = 16 | 32;
+export declare function readUInt(buffer: Buffer, bits: Bits, offset: number, isBigEndian: boolean): number;
+export {};

package/dist/assets/vendor/image-size/readUInt.js

@@ -0,0 +1,9 @@
+function readUInt(buffer, bits, offset, isBigEndian) {
+  offset = offset || 0;
+  const endian = isBigEndian ? "BE" : "LE";
+  const methodName = "readUInt" + bits + endian;
+  return buffer[methodName].call(buffer, offset);
+}
+export {
+  readUInt
+};

package/dist/assets/vendor/image-size/types/bmp.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const BMP: IImage;

package/dist/assets/vendor/image-size/types/bmp.js

@@ -0,0 +1,14 @@
+const BMP = {
+  validate(buffer) {
+    return "BM" === buffer.toString("ascii", 0, 2);
+  },
+  calculate(buffer) {
+    return {
+      height: Math.abs(buffer.readInt32LE(22)),
+      width: buffer.readUInt32LE(18)
+    };
+  }
+};
+export {
+  BMP
+};

package/dist/assets/vendor/image-size/types/cur.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const CUR: IImage;

package/dist/assets/vendor/image-size/types/cur.js

@@ -0,0 +1,16 @@
+import { ICO } from "./ico.js";
+const TYPE_CURSOR = 2;
+const CUR = {
+  validate(buffer) {
+    if (buffer.readUInt16LE(0) !== 0) {
+      return false;
+    }
+    return buffer.readUInt16LE(2) === TYPE_CURSOR;
+  },
+  calculate(buffer) {
+    return ICO.calculate(buffer);
+  }
+};
+export {
+  CUR
+};

package/dist/assets/vendor/image-size/types/dds.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const DDS: IImage;

package/dist/assets/vendor/image-size/types/dds.js

@@ -0,0 +1,14 @@
+const DDS = {
+  validate(buffer) {
+    return buffer.readUInt32LE(0) === 542327876;
+  },
+  calculate(buffer) {
+    return {
+      height: buffer.readUInt32LE(12),
+      width: buffer.readUInt32LE(16)
+    };
+  }
+};
+export {
+  DDS
+};

package/dist/assets/vendor/image-size/types/gif.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const GIF: IImage;

package/dist/assets/vendor/image-size/types/gif.js

@@ -0,0 +1,16 @@
+const gifRegexp = /^GIF8[79]a/;
+const GIF = {
+  validate(buffer) {
+    const signature = buffer.toString("ascii", 0, 6);
+    return gifRegexp.test(signature);
+  },
+  calculate(buffer) {
+    return {
+      height: buffer.readUInt16LE(8),
+      width: buffer.readUInt16LE(6)
+    };
+  }
+};
+export {
+  GIF
+};

package/dist/assets/vendor/image-size/types/icns.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const ICNS: IImage;