astro 2.0.17 → 2.1.0

package/dist/assets/types.d.ts

@@ -0,0 +1,119 @@
+import { VALID_INPUT_FORMATS, VALID_OUTPUT_FORMATS } from './consts.js';
+import { 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] | (string & {});
+export type OutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
+declare global {
+    var astroAsset: {
+        imageService?: ImageService;
+        addStaticImage?: ((options: ImageTransform) => string) | undefined;
+        staticImages?: Map<ImageTransform, string>;
+    };
+}
+/**
+ * Type returned by ESM imports of images and direct calls to imageMetadata
+ */
+export interface ImageMetadata {
+    src: string;
+    width: number;
+    height: number;
+    format: InputFormat;
+}
+/**
+ * Options accepted by the image transformation service.
+ */
+export type ImageTransform = {
+    src: ImageMetadata | string;
+    width?: number;
+    height?: number;
+    quality?: ImageQuality;
+    format?: OutputFormat;
+    [key: string]: any;
+};
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type ImageSharedProps<T> = T & {
+    /**
+     * Width of the image, the value of this property will be used to assign the `width` property on the final `img` element.
+     *
+     * For local images, this value will additionally be used to resize the image to the desired width, taking into account the original aspect ratio of the image.
+     *
+     * **Example**:
+     * ```astro
+     * <Image src={...} width={300} alt="..." />
+     * ```
+     * **Result**:
+     * ```html
+     * <img src="..." width="300" height="..." alt="..." />
+     * ```
+     */
+    width?: number | `${number}`;
+    /**
+     * Height of the image, the value of this property will be used to assign the `height` property on the final `img` element.
+     *
+     * For local images, if `width` is not present, this value will additionally be used to resize the image to the desired height, taking into account the original aspect ratio of the image.
+     *
+     * **Example**:
+     * ```astro
+     * <Image src={...} height={300} alt="..." />
+     * ```
+     * **Result**:
+     * ```html
+     * <img src="..." height="300" width="..." alt="..." />
+     * ```
+     */
+    height?: number | `${number}`;
+};
+export type LocalImageProps<T> = ImageSharedProps<T> & {
+    /**
+     * A reference to a local image imported through an ESM import.
+     *
+     * **Example**:
+     * ```js
+     * import myImage from "~/assets/my_image.png";
+     * ```
+     * And then refer to the image, like so:
+     * ```astro
+     *	<Image src={myImage} alt="..."></Image>
+     * ```
+     */
+    src: ImageMetadata;
+    /**
+     * Desired output format for the image. Defaults to `webp`.
+     *
+     * **Example**:
+     * ```astro
+     * <Image src={...} format="avif" alt="..." />
+     * ```
+     */
+    format?: OutputFormat;
+    /**
+     * 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.
+     * 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**:
+     * ```astro
+     * <Image src={...} quality='high' alt="..." />
+     * <Image src={...} quality={300} alt="..." />
+     * ```
+     */
+    quality?: ImageQuality;
+};
+export type RemoteImageProps<T> = WithRequired<ImageSharedProps<T>, 'width' | 'height'> & {
+    /**
+     * URL of a remote image. Can start with a protocol (ex: `https://`) or alternatively `/`, or `Astro.url`, for images in the `public` folder
+     *
+     * Remote images are not optimized, and require both `width` and `height` to be set.
+     *
+     * **Example**:
+     * ```
+     * <Image src="https://example.com/image.png" width={450} height={300} alt="..." />
+     * ```
+     */
+    src: string;
+};
+export {};

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

@@ -0,0 +1,12 @@
+/**
+ * FNV-1a Hash implementation
+ * @author Travis Webb (tjwebb) <me@traviswebb.com>
+ *
+ * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
+ * License https://github.com/tjwebb/fnv-plus#license
+ *
+ * Simplified, optimized and add modified for 52 bit, which provides a larger hash space
+ * and still making use of Javascript's 53-bit integer space.
+ */
+export declare const fnv1a52: (str: string) => number;
+export declare const etag: (payload: string, weak?: boolean) => string;

package/dist/assets/utils/etag.js

@@ -0,0 +1,28 @@
+const fnv1a52 = (str) => {
+  const len = str.length;
+  let i = 0, t0 = 0, v0 = 8997, t1 = 0, v1 = 33826, t2 = 0, v2 = 40164, t3 = 0, v3 = 52210;
+  while (i < len) {
+    v0 ^= str.charCodeAt(i++);
+    t0 = v0 * 435;
+    t1 = v1 * 435;
+    t2 = v2 * 435;
+    t3 = v3 * 435;
+    t2 += v0 << 8;
+    t3 += v1 << 8;
+    t1 += t0 >>> 16;
+    v0 = t0 & 65535;
+    t2 += t1 >>> 16;
+    v1 = t1 & 65535;
+    v3 = t3 + (t2 >>> 16) & 65535;
+    v2 = t2 & 65535;
+  }
+  return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+};
+const etag = (payload, weak = false) => {
+  const prefix = weak ? 'W/"' : '"';
+  return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
+};
+export {
+  etag,
+  fnv1a52
+};

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { ImageMetadata } from '../types.js';
+export interface Metadata extends ImageMetadata {
+    orientation?: number;
+}
+export declare function imageMetadata(src: URL | string, data?: Buffer): Promise<Metadata | undefined>;

package/dist/assets/utils/metadata.js

@@ -0,0 +1,30 @@
+import { createRequire } from "module";
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+const require2 = createRequire(import.meta.url);
+const sizeOf = require2("image-size");
+async function imageMetadata(src, data) {
+  let file = data;
+  if (!file) {
+    try {
+      file = await fs.readFile(src);
+    } catch (e) {
+      return void 0;
+    }
+  }
+  const { width, height, type, orientation } = await sizeOf(file);
+  const isPortrait = (orientation || 0) >= 5;
+  if (!width || !height || !type) {
+    return void 0;
+  }
+  return {
+    src: fileURLToPath(src),
+    width: isPortrait ? height : width,
+    height: isPortrait ? width : height,
+    format: type,
+    orientation
+  };
+}
+export {
+  imageMetadata
+};

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

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

package/dist/assets/utils/queryParams.js

@@ -0,0 +1,16 @@
+function getOrigQueryParams(params) {
+  const width = params.get("origWidth");
+  const height = params.get("origHeight");
+  const format = params.get("origFormat");
+  if (!width || !height || !format) {
+    return void 0;
+  }
+  return {
+    width: parseInt(width),
+    height: parseInt(height),
+    format
+  };
+}
+export {
+  getOrigQueryParams
+};

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

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

package/dist/assets/utils/transformToPath.js

@@ -0,0 +1,17 @@
+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) {
+  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}_${shorthash(JSON.stringify(transform))}${outputExt}`;
+}
+export {
+  propsToFilename
+};

package/dist/assets/vite-plugin-assets.d.ts

@@ -0,0 +1,5 @@
+import type * as vite from 'vite';
+import { AstroPluginOptions } from '../@types/astro';
+export default function assets({ settings, logging, mode, }: AstroPluginOptions & {
+    mode: string;
+}): vite.Plugin[];

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

@@ -0,0 +1,187 @@
+import MagicString from "magic-string";
+import mime from "mime";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { normalizePath } from "vite";
+import { error } from "../core/logger/core.js";
+import { 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";
+import { copyWasmFiles } from "./services/vendor/squoosh/copy-wasm.js";
+import { imageMetadata } from "./utils/metadata.js";
+import { getOrigQueryParams } from "./utils/queryParams.js";
+import { propsToFilename } from "./utils/transformToPath.js";
+const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
+function assets({
+  settings,
+  logging,
+  mode
+}) {
+  let resolvedConfig;
+  globalThis.astroAsset = {};
+  return [
+    {
+      name: "astro:assets",
+      config() {
+        return {
+          resolve: {
+            alias: [
+              {
+                find: /^~\/assets\/(.+)$/,
+                replacement: fileURLToPath(new URL("./assets/$1", settings.config.srcDir))
+              }
+            ]
+          }
+        };
+      },
+      async resolveId(id) {
+        if (id === VIRTUAL_SERVICE_ID) {
+          return await this.resolve(settings.config.image.service);
+        }
+        if (id === VIRTUAL_MODULE_ID) {
+          return resolvedVirtualModuleId;
+        }
+      },
+      load(id) {
+        if (id === resolvedVirtualModuleId) {
+          return `
+					export { getImage, getConfiguredImageService } from "astro/assets";
+					export { default as Image } from "astro/components/Image.astro";
+				`;
+        }
+      },
+      configureServer(server) {
+        server.middlewares.use(async (req, res, next) => {
+          var _a;
+          if ((_a = req.url) == null ? void 0 : _a.startsWith("/_image")) {
+            if (!isLocalService(globalThis.astroAsset.imageService)) {
+              return next();
+            }
+            const url = new URL(req.url, "file:");
+            const filePath = url.searchParams.get("href");
+            if (!filePath) {
+              return next();
+            }
+            const filePathURL = new URL(filePath, "file:");
+            const file = await fs.readFile(filePathURL.pathname);
+            let meta = getOrigQueryParams(filePathURL.searchParams);
+            if (!meta) {
+              meta = await imageMetadata(filePathURL, file);
+              if (!meta) {
+                return next();
+              }
+            }
+            const transform = await globalThis.astroAsset.imageService.parseURL(url);
+            if (transform === void 0) {
+              error(logging, "image", `Failed to parse transform for ${url}`);
+            }
+            let data = file;
+            let format = meta.format;
+            if (transform) {
+              const result = await globalThis.astroAsset.imageService.transform(file, transform);
+              data = result.data;
+              format = result.format;
+            }
+            res.setHeader("Content-Type", mime.getType(fileURLToPath(url)) || `image/${format}`);
+            res.setHeader("Cache-Control", "max-age=360000");
+            const stream = Readable.from(data);
+            return stream.pipe(res);
+          }
+          return next();
+        });
+      },
+      buildStart() {
+        if (mode != "build") {
+          return;
+        }
+        globalThis.astroAsset.addStaticImage = (options) => {
+          if (!globalThis.astroAsset.staticImages) {
+            globalThis.astroAsset.staticImages = /* @__PURE__ */ new Map();
+          }
+          let filePath;
+          if (globalThis.astroAsset.staticImages.has(options)) {
+            filePath = globalThis.astroAsset.staticImages.get(options);
+          } else {
+            if (!isESMImportedImage(options.src)) {
+              return options.src;
+            }
+            filePath = prependForwardSlash(
+              joinPaths(
+                settings.config.base,
+                settings.config.build.assets,
+                propsToFilename(options)
+              )
+            );
+            globalThis.astroAsset.staticImages.set(options, filePath);
+          }
+          return 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));
+      },
+      async renderChunk(code) {
+        const assetUrlRE = /__ASTRO_ASSET_IMAGE__([a-z\d]{8})__(?:_(.*?)__)?/g;
+        let match;
+        let s;
+        while (match = assetUrlRE.exec(code)) {
+          s = s || (s = new MagicString(code));
+          const [full, hash, postfix = ""] = match;
+          const file = this.getFileName(hash);
+          const outputFilepath = normalizePath(resolvedConfig.base + file + postfix);
+          s.overwrite(match.index, match.index + full.length, outputFilepath);
+        }
+        if (s) {
+          return {
+            code: s.toString(),
+            map: resolvedConfig.build.sourcemap ? s.generateMap({ hires: true }) : null
+          };
+        } else {
+          return null;
+        }
+      }
+    },
+    {
+      name: "astro:assets:esm",
+      enforce: "pre",
+      configResolved(viteConfig) {
+        resolvedConfig = viteConfig;
+      },
+      async load(id) {
+        if (/\.(heic|heif|avif|jpeg|jpg|png|tiff|webp|gif)$/.test(id)) {
+          const url = pathToFileURL(id);
+          const meta = await imageMetadata(url);
+          if (!meta) {
+            return;
+          }
+          if (!this.meta.watchMode) {
+            const pathname = decodeURI(url.pathname);
+            const filename = path.basename(pathname, path.extname(pathname) + `.${meta.format}`);
+            const handle = this.emitFile({
+              name: filename,
+              source: await fs.readFile(url),
+              type: "asset"
+            });
+            meta.src = `__ASTRO_ASSET_IMAGE__${handle}__`;
+          } else {
+            url.searchParams.append("origWidth", meta.width.toString());
+            url.searchParams.append("origHeight", meta.height.toString());
+            url.searchParams.append("origFormat", meta.format);
+            meta.src = url.toString();
+          }
+          return `export default ${JSON.stringify(meta)}`;
+        }
+      }
+    }
+  ];
+}
+export {
+  assets as default
+};

package/dist/cli/check/index.d.ts

@@ -1,5 +1,84 @@
+/// <reference types="node" />
+import { AstroCheck } from '@astrojs/language-server';
+import fsMod from 'fs';
+import type { Arguments as Flags } from 'yargs-parser';
 import type { AstroSettings } from '../../@types/astro';
 import type { LogOptions } from '../../core/logger/core.js';
-export declare function check(settings: AstroSettings, { logging }: {
+import type { ProcessExit, SyncOptions } from '../../core/sync';
+export type CheckPayload = {
+    /**
+     * Flags passed via CLI
+     */
+    flags: Flags;
+    /**
+     * Logging options
+     */
     logging: LogOptions;
-}): Promise<0 | 1>;
+};
+/**
+ *
+ * Types of response emitted by the checker
+ */
+export declare enum CheckResult {
+    /**
+     * Operation finished without errors
+     */
+    ExitWithSuccess = 0,
+    /**
+     * Operation finished with errors
+     */
+    ExitWithError = 1,
+    /**
+     * The consumer should not terminate the operation
+     */
+    Listen = 2
+}
+/**
+ * Checks `.astro` files for possible errors.
+ *
+ * If the `--watch` flag is provided, the command runs indefinitely and provides diagnostics
+ * when `.astro` files are modified.
+ *
+ * Every time an astro files is modified, content collections are also generated.
+ *
+ * @param {AstroSettings} settings
+ * @param {CheckPayload} options Options passed {@link AstroChecker}
+ * @param {Flags} options.flags Flags coming from the CLI
+ * @param {LogOptions} options.logging Logging options
+ */
+export declare function check(settings: AstroSettings, { logging, flags }: CheckPayload): Promise<AstroChecker | undefined>;
+type CheckerConstructor = {
+    diagnosticChecker: AstroCheck;
+    isWatchMode: boolean;
+    syncCli: (settings: AstroSettings, options: SyncOptions) => Promise<ProcessExit>;
+    settings: Readonly<AstroSettings>;
+    logging: Readonly<LogOptions>;
+    fileSystem: typeof fsMod;
+};
+/**
+ * Responsible to check files - classic or watch mode - and report diagnostics.
+ *
+ * When in watch mode, the class does a whole check pass, and then starts watching files.
+ * When a change occurs to an `.astro` file, the checker builds content collections again and lint all the `.astro` files.
+ */
+export declare class AstroChecker {
+    #private;
+    constructor({ diagnosticChecker, isWatchMode, syncCli, settings, fileSystem, logging, }: CheckerConstructor);
+    /**
+     * Check all `.astro` files once and then finishes the operation.
+     */
+    check(): Promise<CheckResult>;
+    /**
+     * Check all `.astro` files and then start watching for changes.
+     */
+    watch(): Promise<CheckResult>;
+    /**
+     * Stops the watch. It terminates the inner server.
+     */
+    stop(): Promise<void>;
+    /**
+     * Whether the checker should run in watch mode
+     */
+    get isWatchMode(): boolean;
+}
+export {};