full site update

node_modules/astro/dist/assets/build/generate.d.ts

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

node_modules/astro/dist/assets/build/generate.js

@@ -6,12 +6,11 @@ import { getTimeStat } from "../../core/build/util.js";
 import { AstroError } from "../../core/errors/errors.js";
 import { AstroErrorData } from "../../core/errors/index.js";
 import { isRemotePath, removeLeadingForwardSlash } from "../../core/path.js";
-import { isServerLikeOutput } from "../../core/util.js";
 import { getConfiguredImageService } from "../internal.js";
 import { isESMImportedImage } from "../utils/imageKind.js";
-import { loadRemoteImage } from "./remote.js";
+import { loadRemoteImage, revalidateRemoteImage } from "./remote.js";
 async function prepareAssetsGenerationEnv(pipeline, totalCount) {
-  const { config, logger } = pipeline;
+  const { config, logger, settings } = pipeline;
   let useCache = true;
   const assetsCacheDir = new URL("assets/", config.cacheDir);
   const count = { total: totalCount, current: 1 };
@@ -24,8 +23,9 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
     );
     useCache = false;
   }
+  const isServerOutput = settings.buildOutput === "server";
   let serverRoot, clientRoot;
-  if (isServerLikeOutput(config)) {
+  if (isServerOutput) {
     serverRoot = config.build.server;
     clientRoot = config.build.client;
   } else {
@@ -34,7 +34,7 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
   }
   return {
     logger,
-    isSSR: isServerLikeOutput(config),
+    isSSR: isServerOutput,
     count,
     useCache,
     assetsCacheDir,
@@ -47,12 +47,10 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
 function getFullImagePath(originalFilePath, env) {
   return new URL(removeLeadingForwardSlash(originalFilePath), env.serverRoot);
 }
-async function generateImagesForPath(originalFilePath, transformsAndPath, env, queue) {
+async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
   let originalImage;
   for (const [_, transform] of transformsAndPath.transforms) {
-    await queue.add(async () => generateImage(transform.finalPath, transform.transform)).catch((e) => {
-      throw e;
-    });
+    await generateImage(transform.finalPath, transform.transform);
   }
   if (!env.isSSR && transformsAndPath.originalSrcPath && !globalThis.astroAsset.referencedImages?.has(transformsAndPath.originalSrcPath)) {
     try {
@@ -72,7 +70,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const timeEnd = performance.now();
     const timeChange = getTimeStat(timeStart, timeEnd);
     const timeIncrease = `(+${timeChange})`;
-    const statsText = generationData.cached ? `(reused cache entry)` : `(before: ${generationData.weight.before}kB, after: ${generationData.weight.after}kB)`;
+    const statsText = generationData.cached !== "miss" ? generationData.cached === "hit" ? `(reused cache entry)` : `(revalidated cache entry)` : `(before: ${generationData.weight.before}kB, after: ${generationData.weight.after}kB)`;
     const count = `(${env.count.current}/${env.count.total})`;
     env.logger.info(
       null,
@@ -85,30 +83,69 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const finalFileURL = new URL("." + filepath, env.clientRoot);
     const finalFolderURL = new URL("./", finalFileURL);
     await fs.promises.mkdir(finalFolderURL, { recursive: true });
-    const cacheFile = basename(filepath) + (isLocalImage ? "" : ".json");
+    const cacheFile = basename(filepath);
     const cachedFileURL = new URL(cacheFile, env.assetsCacheDir);
+    const cacheMetaFile = cacheFile + ".json";
+    const cachedMetaFileURL = new URL(cacheMetaFile, env.assetsCacheDir);
     try {
       if (isLocalImage) {
         await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
         return {
-          cached: true
+          cached: "hit"
         };
       } else {
-        const JSONData = JSON.parse(readFileSync(cachedFileURL, "utf-8"));
-        if (!JSONData.data || !JSONData.expires) {
-          await fs.promises.unlink(cachedFileURL);
+        const JSONData = JSON.parse(readFileSync(cachedMetaFileURL, "utf-8"));
+        if (!JSONData.expires) {
+          try {
+            await fs.promises.unlink(cachedFileURL);
+          } catch {
+          }
+          await fs.promises.unlink(cachedMetaFileURL);
           throw new Error(
             `Malformed cache entry for ${filepath}, cache will be regenerated for this file.`
           );
         }
-        if (JSONData.expires > Date.now()) {
-          await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
-          return {
-            cached: true
-          };
-        } else {
-          await fs.promises.unlink(cachedFileURL);
+        if (JSONData.data) {
+          const { data, ...meta } = JSONData;
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, Buffer.from(data, "base64")),
+            writeCacheMetaFile(cachedMetaFileURL, meta, env)
+          ]);
         }
+        if (JSONData.expires > Date.now()) {
+          await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
+          return {
+            cached: "hit"
+          };
+        }
+        if (JSONData.etag || JSONData.lastModified) {
+          try {
+            const revalidatedData = await revalidateRemoteImage(options.src, {
+              etag: JSONData.etag,
+              lastModified: JSONData.lastModified
+            });
+            if (revalidatedData.data.length) {
+              originalImage = revalidatedData;
+            } else {
+              await writeCacheMetaFile(cachedMetaFileURL, revalidatedData, env);
+              await fs.promises.copyFile(
+                cachedFileURL,
+                finalFileURL,
+                fs.constants.COPYFILE_FICLONE
+              );
+              return { cached: "revalidated" };
+            }
+          } catch (e) {
+            env.logger.warn(
+              null,
+              `An error was encountered while revalidating a cached remote asset. Proceeding with stale cache. ${e}`
+            );
+            await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
+            return { cached: "hit" };
+          }
+        }
+        await fs.promises.unlink(cachedFileURL);
+        await fs.promises.unlink(cachedMetaFileURL);
       }
     } catch (e) {
       if (e.code !== "ENOENT") {
@@ -121,7 +158,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     }
     let resultData = {
       data: void 0,
-      expires: originalImage.expires
+      expires: originalImage.expires,
+      etag: originalImage.etag,
+      lastModified: originalImage.lastModified
     };
     const imageService = await getConfiguredImageService();
     try {
@@ -131,6 +170,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
         env.imageConfig
       )).data;
     } catch (e) {
+      if (AstroError.is(e)) {
+        throw e;
+      }
       const error = new AstroError(
         {
           ...AstroErrorData.CouldNotTransformImage,
@@ -145,13 +187,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
         if (isLocalImage) {
           await fs.promises.writeFile(cachedFileURL, resultData.data);
         } else {
-          await fs.promises.writeFile(
-            cachedFileURL,
-            JSON.stringify({
-              data: Buffer.from(resultData.data).toString("base64"),
-              expires: resultData.expires
-            })
-          );
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, resultData.data),
+            writeCacheMetaFile(cachedMetaFileURL, resultData, env)
+          ]);
         }
       }
     } catch (e) {
@@ -163,7 +202,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
       await fs.promises.writeFile(finalFileURL, resultData.data);
     }
     return {
-      cached: false,
+      cached: "miss",
       weight: {
         // Divide by 1024 to get size in kilobytes
         before: Math.trunc(originalImage.data.byteLength / 1024),
@@ -172,6 +211,23 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     };
   }
 }
+async function writeCacheMetaFile(cachedMetaFileURL, resultData, env) {
+  try {
+    return await fs.promises.writeFile(
+      cachedMetaFileURL,
+      JSON.stringify({
+        expires: resultData.expires,
+        etag: resultData.etag,
+        lastModified: resultData.lastModified
+      })
+    );
+  } catch (e) {
+    env.logger.warn(
+      null,
+      `An error was encountered while writing the cache file for a remote asset. Proceeding without caching this asset. Error: ${e}`
+    );
+  }
+}
 function getStaticImageList() {
   if (!globalThis?.astroAsset?.staticImages) {
     return /* @__PURE__ */ new Map();
@@ -180,11 +236,7 @@ function getStaticImageList() {
 }
 async function loadImage(path, env) {
   if (isRemotePath(path)) {
-    const remoteImage = await loadRemoteImage(path);
-    return {
-      data: remoteImage.data,
-      expires: remoteImage.expires
-    };
+    return await loadRemoteImage(path);
   }
   return {
     data: await fs.promises.readFile(getFullImagePath(path, env)),

node_modules/astro/dist/assets/build/remote.d.ts

@@ -1,8 +1,30 @@
 export type RemoteCacheEntry = {
-    data: string;
+    data?: string;
     expires: number;
+    etag?: string;
+    lastModified?: string;
 };
 export declare function loadRemoteImage(src: string): Promise<{
     data: Buffer;
     expires: number;
+    etag: string | undefined;
+    lastModified: string | undefined;
+}>;
+/**
+ * Revalidate a cached remote asset using its entity-tag or modified date.
+ * Uses the [If-None-Match](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match) and [If-Modified-Since](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Modified-Since)
+ * headers to check with the remote server if the cached version of a remote asset is still up to date.
+ * The remote server may respond that the cached asset is still up-to-date if the entity-tag or modification time matches (304 Not Modified), or respond with an updated asset (200 OK)
+ * @param src - url to remote asset
+ * @param revalidationData - an object containing the stored Entity-Tag of the cached asset and/or the Last Modified time
+ * @returns An ImageData object containing the asset data, a new expiry time, and the asset's etag. The data buffer will be empty if the asset was not modified.
+ */
+export declare function revalidateRemoteImage(src: string, revalidationData: {
+    etag?: string;
+    lastModified?: string;
+}): Promise<{
+    data: Buffer;
+    expires: number;
+    etag: string | undefined;
+    lastModified: string | undefined;
 }>;

node_modules/astro/dist/assets/build/remote.js

@@ -11,7 +11,41 @@ async function loadRemoteImage(src) {
   const expires = policy.storable() ? policy.timeToLive() : 0;
   return {
     data: Buffer.from(await res.arrayBuffer()),
-    expires: Date.now() + expires
+    expires: Date.now() + expires,
+    etag: res.headers.get("Etag") ?? void 0,
+    lastModified: res.headers.get("Last-Modified") ?? void 0
+  };
+}
+async function revalidateRemoteImage(src, revalidationData) {
+  const headers = {
+    ...revalidationData.etag && { "If-None-Match": revalidationData.etag },
+    ...revalidationData.lastModified && { "If-Modified-Since": revalidationData.lastModified }
+  };
+  const req = new Request(src, { headers });
+  const res = await fetch(req);
+  if (!res.ok && res.status !== 304) {
+    throw new Error(
+      `Failed to revalidate cached remote image ${src}. The request did not return a 200 OK / 304 NOT MODIFIED response. (received ${res.status} ${res.statusText})`
+    );
+  }
+  const data = Buffer.from(await res.arrayBuffer());
+  if (res.ok && !data.length) {
+    return await loadRemoteImage(src);
+  }
+  const policy = new CachePolicy(
+    webToCachePolicyRequest(req),
+    webToCachePolicyResponse(
+      res.ok ? res : new Response(null, { status: 200, headers: res.headers })
+    )
+    // 304 responses themselves are not cacheable, so just pretend to get the refreshed TTL
+  );
+  const expires = policy.storable() ? policy.timeToLive() : 0;
+  return {
+    data,
+    expires: Date.now() + expires,
+    // While servers should respond with the same headers as a 200 response, if they don't we should reuse the stored value
+    etag: res.headers.get("Etag") ?? (res.ok ? void 0 : revalidationData.etag),
+    lastModified: res.headers.get("Last-Modified") ?? (res.ok ? void 0 : revalidationData.lastModified)
   };
 }
 function webToCachePolicyRequest({ url, method, headers: _headers }) {
@@ -38,5 +72,6 @@ function webToCachePolicyResponse({ status, headers: _headers }) {
   };
 }
 export {
-  loadRemoteImage
+  loadRemoteImage,
+  revalidateRemoteImage
 };