astro 5.16.13 → 5.16.15

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

@@ -1,7 +1,6 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { isAbsolute } from "node:path";
-import { fileURLToPath } from "node:url";
 import colors from "piccolore";
 import { getAlgorithm, shouldTrackCspHashes } from "../../core/csp/common.js";
 import { generateCspDigest } from "../../core/encryption.js";
@@ -21,26 +20,28 @@ import {
   RUNTIME_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 } from "./constants.js";
-import { BuildUrlProxyHashResolver } from "./infra/build-url-proxy-hash-resolver.js";
+import { collectComponentData } from "./core/collect-component-data.js";
+import { collectFontAssetsFromFaces } from "./core/collect-font-assets-from-faces.js";
+import { collectFontData } from "./core/collect-font-data.js";
+import { computeFontFamiliesAssets } from "./core/compute-font-families-assets.js";
+import { filterAndTransformFontFaces } from "./core/filter-and-transform-font-faces.js";
+import { getOrCreateFontFamilyAssets } from "./core/get-or-create-font-family-assets.js";
+import { optimizeFallbacks } from "./core/optimize-fallbacks.js";
+import { resolveFamily } from "./core/resolve-family.js";
+import { BuildFontFileIdGenerator } from "./infra/build-font-file-id-generator.js";
 import { BuildUrlResolver } from "./infra/build-url-resolver.js";
 import { CachedFontFetcher } from "./infra/cached-font-fetcher.js";
 import { CapsizeFontMetricsResolver } from "./infra/capsize-font-metrics-resolver.js";
-import { RealDataCollector } from "./infra/data-collector.js";
-import { DevUrlProxyHashResolver } from "./infra/dev-url-proxy-hash-resolver.js";
+import { DevFontFileIdGenerator } from "./infra/dev-font-file-id-generator.js";
 import { DevUrlResolver } from "./infra/dev-url-resolver.js";
-import { RealFontTypeExtractor } from "./infra/font-type-extractor.js";
-import { FontaceFontFileReader } from "./infra/fontace-font-file-reader.js";
+import { FsFontFileContentResolver } from "./infra/fs-font-file-content-resolver.js";
 import { LevenshteinStringMatcher } from "./infra/levenshtein-string-matcher.js";
-import { LocalUrlProxyContentResolver } from "./infra/local-url-proxy-content-resolver.js";
 import { MinifiableCssRenderer } from "./infra/minifiable-css-renderer.js";
-import { RemoteUrlProxyContentResolver } from "./infra/remote-url-proxy-content-resolver.js";
-import { RequireLocalProviderUrlResolver } from "./infra/require-local-provider-url-resolver.js";
+import { NodeFontTypeExtractor } from "./infra/node-font-type-extractor.js";
 import { RealSystemFallbacksProvider } from "./infra/system-fallbacks-provider.js";
 import { UnifontFontResolver } from "./infra/unifont-font-resolver.js";
 import { UnstorageFsStorage } from "./infra/unstorage-fs-storage.js";
-import { RealUrlProxy } from "./infra/url-proxy.js";
 import { XxhashHasher } from "./infra/xxhash-hasher.js";
-import { orchestrate } from "./orchestrate.js";
 function fontsPlugin({ settings, sync, logger }) {
   if (!settings.config.experimental.fonts) {
     return {
@@ -69,137 +70,134 @@ function fontsPlugin({ settings, sync, logger }) {
     appendForwardSlash(joinPaths(settings.config.build.assets, ASSETS_DIR))
   );
   const baseUrl = joinPaths(settings.config.base, assetsDir);
-  let fontFileDataMap = null;
-  let internalConsumableMap = null;
-  let fontData = null;
+  let fontFileById = null;
+  let componentDataByCssVariable = null;
+  let fontDataByCssVariable = null;
   let isBuild;
   let fontFetcher = null;
   let fontTypeExtractor = null;
   const cleanup = () => {
-    internalConsumableMap = null;
-    fontData = null;
-    fontFileDataMap = null;
+    componentDataByCssVariable = null;
+    fontDataByCssVariable = null;
+    fontFileById = null;
     fontFetcher = null;
   };
-  async function initialize({
-    cacheDir,
-    cssRenderer,
-    urlResolver,
-    createHashResolver
-  }) {
-    const { root } = settings.config;
-    const hasher = await XxhashHasher.create();
-    const pathsToWarn = /* @__PURE__ */ new Set();
-    const localProviderUrlResolver = new RequireLocalProviderUrlResolver({
-      root,
-      intercept: (path) => {
-        if (path.startsWith(fileURLToPath(settings.config.publicDir))) {
-          if (pathsToWarn.has(path)) {
-            return;
-          }
-          pathsToWarn.add(path);
-          logger.warn(
-            "assets",
-            `Found a local font file ${JSON.stringify(path)} in the \`public/\` folder. To avoid duplicated files in the build output, move this file into \`src/\``
-          );
-        }
-      }
-    });
-    const storage = new UnstorageFsStorage({ base: cacheDir });
-    const systemFallbacksProvider = new RealSystemFallbacksProvider();
-    fontFetcher = new CachedFontFetcher({ storage, fetch, readFile });
-    const fontMetricsResolver = new CapsizeFontMetricsResolver({ fontFetcher, cssRenderer });
-    fontTypeExtractor = new RealFontTypeExtractor();
-    const fontFileReader = new FontaceFontFileReader();
-    const stringMatcher = new LevenshteinStringMatcher();
-    const res = await orchestrate({
-      families: settings.config.experimental.fonts,
-      hasher,
-      localProviderUrlResolver,
-      createFontResolver: async ({ families }) => await UnifontFontResolver.create({
-        families,
-        hasher,
-        storage
-      }),
-      cssRenderer,
-      systemFallbacksProvider,
-      fontMetricsResolver,
-      fontTypeExtractor,
-      fontFileReader,
-      logger,
-      createUrlProxy: ({ local, cssVariable, ...params }) => {
-        const dataCollector = new RealDataCollector(params);
-        const contentResolver = local ? new LocalUrlProxyContentResolver() : new RemoteUrlProxyContentResolver();
-        return new RealUrlProxy({
-          urlResolver,
-          hashResolver: createHashResolver({ hasher, contentResolver }),
-          dataCollector,
-          cssVariable
-        });
-      },
-      defaults: DEFAULTS,
-      bold: colors.bold,
-      stringMatcher
-    });
-    fontFileDataMap = res.fontFileDataMap;
-    internalConsumableMap = res.internalConsumableMap;
-    fontData = res.fontData;
-    if (shouldTrackCspHashes(settings.config.experimental.csp)) {
-      const algorithm = getAlgorithm(settings.config.experimental.csp);
-      for (const { css } of internalConsumableMap.values()) {
-        settings.injectedCsp.styleHashes.push(await generateCspDigest(css, algorithm));
-      }
-      for (const resource of urlResolver.cspResources) {
-        settings.injectedCsp.fontResources.add(resource);
-      }
-    }
-  }
   return {
     name: "astro:fonts",
     config(_, { command }) {
       isBuild = command === "build";
     },
     async buildStart() {
-      if (isBuild) {
-        await initialize({
-          cacheDir: new URL(CACHE_DIR, settings.config.cacheDir),
-          cssRenderer: new MinifiableCssRenderer({ minify: true }),
-          urlResolver: new BuildUrlResolver({
-            base: baseUrl,
-            assetsPrefix: settings.config.build.assetsPrefix,
-            searchParams: settings.adapter?.client?.assetQueryParams ?? new URLSearchParams()
-          }),
-          createHashResolver: (dependencies) => new BuildUrlProxyHashResolver(dependencies)
-        });
-      } else {
-        await initialize({
-          // In dev, we cache fonts data in .astro so it can be easily inspected and cleared
-          cacheDir: new URL(CACHE_DIR, settings.dotAstroDir),
-          cssRenderer: new MinifiableCssRenderer({ minify: false }),
-          urlResolver: new DevUrlResolver({
-            base: baseUrl,
-            searchParams: settings.adapter?.client?.assetQueryParams ?? new URLSearchParams()
-          }),
-          createHashResolver: (dependencies) => new DevUrlProxyHashResolver(dependencies)
-        });
+      const { root } = settings.config;
+      const hasher = await XxhashHasher.create();
+      const storage = new UnstorageFsStorage({
+        // In dev, we cache fonts data in .astro so it can be easily inspected and cleared
+        base: new URL(CACHE_DIR, isBuild ? settings.config.cacheDir : settings.dotAstroDir)
+      });
+      const systemFallbacksProvider = new RealSystemFallbacksProvider();
+      fontFetcher = new CachedFontFetcher({ storage, fetch, readFile });
+      const cssRenderer = new MinifiableCssRenderer({ minify: isBuild });
+      const fontMetricsResolver = new CapsizeFontMetricsResolver({ fontFetcher, cssRenderer });
+      fontTypeExtractor = new NodeFontTypeExtractor();
+      const stringMatcher = new LevenshteinStringMatcher();
+      const urlResolver = isBuild ? new BuildUrlResolver({
+        base: baseUrl,
+        assetsPrefix: settings.config.build.assetsPrefix,
+        searchParams: settings.adapter?.client?.assetQueryParams ?? new URLSearchParams()
+      }) : new DevUrlResolver({
+        base: baseUrl,
+        searchParams: settings.adapter?.client?.assetQueryParams ?? new URLSearchParams()
+      });
+      const contentResolver = new FsFontFileContentResolver({
+        readFileSync: (path) => readFileSync(path, "utf-8")
+      });
+      const fontFileIdGenerator = isBuild ? new BuildFontFileIdGenerator({
+        hasher,
+        contentResolver
+      }) : new DevFontFileIdGenerator({
+        hasher,
+        contentResolver
+      });
+      const { bold } = colors;
+      const defaults = DEFAULTS;
+      const resolvedFamilies = settings.config.experimental.fonts.map(
+        (family) => resolveFamily({ family, hasher })
+      );
+      const { fontFamilyAssets, fontFileById: _fontFileById } = await computeFontFamiliesAssets({
+        resolvedFamilies,
+        defaults,
+        bold,
+        logger,
+        stringMatcher,
+        fontResolver: await UnifontFontResolver.create({
+          families: resolvedFamilies,
+          hasher,
+          storage,
+          root
+        }),
+        getOrCreateFontFamilyAssets: ({ family, fontFamilyAssetsByUniqueKey }) => getOrCreateFontFamilyAssets({
+          family,
+          fontFamilyAssetsByUniqueKey,
+          bold,
+          logger
+        }),
+        filterAndTransformFontFaces: ({ family, fonts }) => filterAndTransformFontFaces({
+          family,
+          fonts,
+          fontFileIdGenerator,
+          fontTypeExtractor,
+          urlResolver
+        }),
+        collectFontAssetsFromFaces: ({ collectedFontsIds, family, fontFilesIds, fonts }) => collectFontAssetsFromFaces({
+          collectedFontsIds,
+          family,
+          fontFilesIds,
+          fonts,
+          fontFileIdGenerator,
+          hasher,
+          defaults
+        })
+      });
+      fontDataByCssVariable = collectFontData(fontFamilyAssets);
+      componentDataByCssVariable = await collectComponentData({
+        cssRenderer,
+        defaults,
+        fontFamilyAssets,
+        optimizeFallbacks: ({ collectedFonts, fallbacks, family }) => optimizeFallbacks({
+          collectedFonts,
+          fallbacks,
+          family,
+          fontMetricsResolver,
+          systemFallbacksProvider
+        })
+      });
+      fontFileById = _fontFileById;
+      if (shouldTrackCspHashes(settings.config.experimental.csp)) {
+        const algorithm = getAlgorithm(settings.config.experimental.csp);
+        for (const { css } of componentDataByCssVariable.values()) {
+          settings.injectedCsp.styleHashes.push(await generateCspDigest(css, algorithm));
+        }
+        for (const resource of urlResolver.cspResources) {
+          settings.injectedCsp.fontResources.add(resource);
+        }
       }
     },
     async configureServer(server) {
       server.watcher.on("change", (path) => {
-        if (!fontFileDataMap) {
+        if (!fontFileById) {
           return;
         }
-        const localPaths = [...fontFileDataMap.values()].filter(({ url }) => isAbsolute(url)).map((v) => v.url);
+        const localPaths = [...fontFileById.values()].filter(({ url }) => isAbsolute(url)).map((v) => v.url);
         if (localPaths.includes(path)) {
           logger.info("assets", "Font file updated");
           server.restart();
         }
       });
       server.watcher.on("unlink", (path) => {
-        if (!fontFileDataMap) {
+        if (!fontFileById) {
           return;
         }
-        const localPaths = [...fontFileDataMap.values()].filter(({ url }) => isAbsolute(url)).map((v) => v.url);
+        const localPaths = [...fontFileById.values()].filter(({ url }) => isAbsolute(url)).map((v) => v.url);
         if (localPaths.includes(path)) {
           logger.warn(
             "assets",
@@ -208,21 +206,28 @@ function fontsPlugin({ settings, sync, logger }) {
         }
       });
       server.middlewares.use(assetsDir, async (req, res, next) => {
+        if (!fontFetcher || !fontTypeExtractor) {
+          logger.debug(
+            "assets",
+            "Fonts dependencies should be initialized by now, skipping dev middleware."
+          );
+          return next();
+        }
         if (!req.url) {
           return next();
         }
-        const hash = req.url.slice(1);
-        const associatedData = fontFileDataMap?.get(hash);
-        if (!associatedData) {
+        const fontId = req.url.slice(1);
+        const fontData = fontFileById?.get(fontId);
+        if (!fontData) {
           return next();
         }
         res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
         res.setHeader("Pragma", "no-cache");
         res.setHeader("Expires", 0);
         try {
-          const buffer = await fontFetcher.fetch({ hash, ...associatedData });
-          res.setHeader("Content-Length", buffer.byteLength);
-          res.setHeader("Content-Type", `font/${fontTypeExtractor.extract(hash)}`);
+          const buffer = await fontFetcher.fetch({ id: fontId, ...fontData });
+          res.setHeader("Content-Length", buffer.length);
+          res.setHeader("Content-Type", `font/${fontTypeExtractor.extract(fontId)}`);
           res.end(buffer);
         } catch (err) {
           logger.error("assets", "Cannot download font file");
@@ -252,9 +257,9 @@ function fontsPlugin({ settings, sync, logger }) {
       if (id === RESOLVED_VIRTUAL_MODULE_ID) {
         return {
           code: `
-						export const internalConsumableMap = new Map(${JSON.stringify(Array.from(internalConsumableMap?.entries() ?? []))});
-						export const fontData = ${JSON.stringify(fontData ?? {})};
-						export const bufferImports = {${[...fontFileDataMap?.keys() ?? []].map((key) => `"${key}": () => import("${BUFFER_VIRTUAL_MODULE_ID_PREFIX}${key}")`).join(",")}};
+						export const componentDataByCssVariable = new Map(${JSON.stringify(Array.from(componentDataByCssVariable?.entries() ?? []))});
+						export const fontDataByCssVariable = ${JSON.stringify(fontDataByCssVariable ?? {})}
+						export const bufferImports = {${[...fontFileById?.keys() ?? []].map((key) => `"${key}": () => import("${BUFFER_VIRTUAL_MODULE_ID_PREFIX}${key}")`).join(",")}};
 					`
         };
       }
@@ -269,15 +274,20 @@ function fontsPlugin({ settings, sync, logger }) {
         };
       }
       if (id.startsWith(RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX)) {
-        const hash = id.slice(RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX.length);
-        const associatedData = fontFileDataMap?.get(hash);
-        if (!associatedData) {
-          return {
-            code: `export default null;`
-          };
+        if (!fontFetcher) {
+          logger.debug(
+            "assets",
+            "Fonts dependencies should be initialized by now, skipping dev middleware."
+          );
+          return { code: `export default null;` };
+        }
+        const fontId = id.slice(RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX.length);
+        const fontData = fontFileById?.get(fontId);
+        if (!fontData) {
+          return { code: `export default null;` };
         }
         try {
-          const buffer = await fontFetcher.fetch({ hash, ...associatedData });
+          const buffer = await fontFetcher.fetch({ id: fontId, ...fontData });
           const bytes = Array.from(buffer);
           return {
             code: `export default Uint8Array.from(${JSON.stringify(bytes)});`
@@ -290,9 +300,7 @@ function fontsPlugin({ settings, sync, logger }) {
               formatErrorMessage(collectErrorMetadata(err), logger.level() === "debug")
             );
           }
-          return {
-            code: `export default null;`
-          };
+          return { code: `export default null;` };
         }
       }
     },
@@ -309,16 +317,16 @@ function fontsPlugin({ settings, sync, logger }) {
         } catch (cause) {
           throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
         }
-        if (fontFileDataMap) {
+        if (fontFileById) {
           logger.info(
             "assets",
-            `Copying fonts (${fontFileDataMap.size} file${fontFileDataMap.size === 1 ? "" : "s"})...`
+            `Copying fonts (${fontFileById.size} file${fontFileById.size === 1 ? "" : "s"})...`
           );
           await Promise.all(
-            Array.from(fontFileDataMap.entries()).map(async ([hash, associatedData]) => {
-              const data = await fontFetcher.fetch({ hash, ...associatedData });
+            Array.from(fontFileById.entries()).map(async ([id, associatedData]) => {
+              const data = await fontFetcher.fetch({ id, ...associatedData });
               try {
-                writeFileSync(new URL(hash, fontsDir), data);
+                writeFileSync(new URL(id, fontsDir), data);
               } catch (cause) {
                 throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
               }

package/dist/cli/add/index.js

@@ -289,6 +289,45 @@ async function add(names, { flags }) {
           defaultConfigContent: STUBS.LIT_NPMRC
         });
       }
+      if (integrations.find((integration) => integration.id === "vercel")) {
+        const gitignorePath = new URL("./.gitignore", root);
+        const gitignoreEntry = ".vercel";
+        if (existsSync(gitignorePath)) {
+          const content = await fs.readFile(fileURLToPath(gitignorePath), { encoding: "utf-8" });
+          if (!content.includes(gitignoreEntry)) {
+            logger.info(
+              "SKIP_FORMAT",
+              `
+  ${magenta(`Astro will add ${green(".vercel")} to ${green(".gitignore")}.`)}
+`
+            );
+            if (await askToContinue({ flags, logger })) {
+              const newContent = content.endsWith("\n") ? `${content}${gitignoreEntry}
+` : `${content}
+${gitignoreEntry}
+`;
+              await fs.writeFile(fileURLToPath(gitignorePath), newContent, { encoding: "utf-8" });
+              logger.debug("add", "Updated .gitignore with .vercel");
+            }
+          } else {
+            logger.debug("add", ".vercel already in .gitignore");
+          }
+        } else {
+          logger.info(
+            "SKIP_FORMAT",
+            `
+  ${magenta(`Astro will create ${green(".gitignore")} with ${green(".vercel")}.`)}
+`
+          );
+          if (await askToContinue({ flags, logger })) {
+            await fs.writeFile(fileURLToPath(gitignorePath), `${gitignoreEntry}
+`, {
+              encoding: "utf-8"
+            });
+            logger.debug("add", "Created .gitignore with .vercel");
+          }
+        }
+      }
       break;
     }
     case 2 /* cancelled */: {

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "5.16.13";
+  version = "5.16.15";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/config/index.d.ts

@@ -1,12 +1,11 @@
 import type { UserConfig as ViteUserConfig, UserConfigFn as ViteUserConfigFn } from 'vite';
-import type { LOCAL_PROVIDER_NAME } from '../assets/fonts/constants.js';
 import type { FontProvider } from '../assets/fonts/types.js';
 import type { AstroInlineConfig, AstroUserConfig, Locales, SessionDriverName } from '../types/public/config.js';
 /**
  * See the full Astro Configuration API Documentation
  * https://astro.build/config
  */
-export declare function defineConfig<const TLocales extends Locales = never, const TDriver extends SessionDriverName = never, const TFontProviders extends Array<FontProvider | typeof LOCAL_PROVIDER_NAME> = never>(config: AstroUserConfig<TLocales, TDriver, TFontProviders>): AstroUserConfig<TLocales, TDriver, TFontProviders>;
+export declare function defineConfig<const TLocales extends Locales = never, const TDriver extends SessionDriverName = never, const TFontProviders extends Array<FontProvider> = never>(config: AstroUserConfig<TLocales, TDriver, TFontProviders>): AstroUserConfig<TLocales, TDriver, TFontProviders>;
 /**
  * Use Astro to generate a fully resolved Vite config
  */

package/dist/content/content-layer.js

@@ -164,7 +164,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.16.13") {
+    if (previousAstroVersion && previousAstroVersion !== "5.16.15") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -172,8 +172,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.16.13") {
-      await this.#store.metaStore().set("astro-version", "5.16.13");
+    if ("5.16.15") {
+      await this.#store.metaStore().set("astro-version", "5.16.15");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);