astro 6.0.0-beta.0 → 6.0.0-beta.10

package/README.md

@@ -38,6 +38,6 @@ Join us on [Discord](https://astro.build/chat) to meet other contributors. We'll
 
 ## Sponsors
 
-Astro is generously supported by [Vercel](https://vercel.com/), [storyblok](https://storyblok.com/), and several other amazing organizations [listed here.](https://opencollective.com/astrodotbuild)
+Astro is generously supported by [Cloudflare](https://www.cloudflare.com/pt-br/?utm_source=astro&utm_medium=astro&utm_campaign=astro), [Mux](https://www.mux.com/?utm_campaign=21819274-Astro&utm_source=astro), [Netlify](https://www.netlify.com/?utm_campaign=Astro-2024&utm_source=astro-referral), [Webflow](https://webflow.com/feature/cloud?utm_source=Astro&utm_medium=tech-partner&utm_campaign=fy26-astro&utm_content=fy26-docs), and several [other amazing organizations](https://opencollective.com/astrodotbuild).
 
 [❤️ Sponsor Astro! ❤️](https://github.com/withastro/.github/blob/main/FUNDING.md)

package/bin/astro.mjs

@@ -12,7 +12,7 @@ const CI_INSTRUCTIONS = {
 const IS_STACKBLITZ = !!process.versions.webcontainer;
 
 // Hardcode supported Node.js version so we don't have to read differently in CJS & ESM.
-const engines = IS_STACKBLITZ ? '>=20.19.5' : '>=22.12.0';
+const engines = IS_STACKBLITZ ? '>=20.19.1' : '>=22.12.0';
 const skipSemverCheckIfAbove = IS_STACKBLITZ ? 21 : 23;
 
 /** `astro *` */

package/client.d.ts

@@ -58,9 +58,7 @@ declare module 'astro:assets' {
 		Image: typeof import('./components/Image.astro').default;
 		Picture: typeof import('./components/Picture.astro').default;
 		Font: typeof import('./components/Font.astro').default;
-		getFontData: (
-			cssVariable: import('astro:assets').CssVariable,
-		) => Array<import('astro:assets').FontData>;
+		fontData: Record<import('astro:assets').CssVariable, Array<import('astro:assets').FontData>>;
 	};
 
 	type ImgAttributes = import('./dist/type-utils.js').WithRequired<
@@ -82,7 +80,7 @@ declare module 'astro:assets' {
 		Picture,
 		Font,
 		inferRemoteSize,
-		getFontData,
+		fontData,
 	}: AstroAssets;
 }
 
@@ -288,6 +286,10 @@ declare module 'astro:ssr-manifest' {
 	export const manifest: import('./dist/types/public/internal.js').SSRManifest;
 }
 
+declare module 'astro:static-paths' {
+	export const StaticPaths: typeof import('./dist/runtime/prerender/static-paths.js').StaticPaths;
+}
+
 // Everything below are Vite's types (apart from image types, which are in `client.d.ts`)
 
 // CSS modules

package/components/Code.astro

@@ -1,8 +1,7 @@
 ---
-import type { ThemePresets } from '@astrojs/markdown-remark';
+import { type ThemePresets, createShikiHighlighter } from '@astrojs/markdown-remark';
 import type { ShikiTransformer, ThemeRegistration, ThemeRegistrationRaw } from 'shiki';
 import { bundledLanguages } from 'shiki/langs';
-import { getCachedHighlighter } from '../dist/core/shiki.js';
 import type { CodeLanguage } from '../dist/types/public/common.js';
 import type { HTMLAttributes } from '../types.js';
 
@@ -95,7 +94,7 @@ if (typeof lang === 'object') {
 	}
 }
 
-const highlighter = await getCachedHighlighter({
+const highlighter = await createShikiHighlighter({
 	langs: [
 		typeof lang === 'string'
 			? Object.keys(bundledLanguages).includes(lang)

package/components/Font.astro

@@ -1,14 +1,8 @@
 ---
-import * as mod from 'virtual:astro:assets/fonts/internal';
-import { filterPreloads } from 'astro/assets/fonts/runtime';
+import { componentDataByCssVariable } from 'virtual:astro:assets/fonts/internal';
+import { filterPreloads } from '../dist/assets/fonts/core/filter-preloads.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 
-// TODO: remove check when fonts are stabilized
-const { internalConsumableMap } = mod;
-if (!internalConsumableMap) {
-	throw new AstroError(AstroErrorData.ExperimentalFontsNotEnabled);
-}
-
 interface Props {
 	/** The `cssVariable` registered in your Astro configuration. */
 	cssVariable: import('astro:assets').CssVariable;
@@ -17,7 +11,7 @@ interface Props {
 }
 
 const { cssVariable, preload = false } = Astro.props as Props;
-const data = internalConsumableMap.get(cssVariable);
+const data = componentDataByCssVariable.get(cssVariable);
 if (!data) {
 	throw new AstroError({
 		...AstroErrorData.FontFamilyNotFound,
@@ -25,7 +19,7 @@ if (!data) {
 	});
 }
 
-const filteredPreloadData = filterPreloads(data.preloadData, preload);
+const filteredPreloadData = filterPreloads(data.preloads, preload);
 ---
 
 <style set:html={data.css}></style>

package/components/Picture.astro

@@ -73,13 +73,20 @@ const optimizedImages: GetImageResult[] = await Promise.all(
 	),
 );
 
+// Clone the `src` object if it's an ESM import so that we don't refer to any properties of the original object
+// Causing our generate step to think the image is used outside of the image optimization pipeline
+const clonedSrc = isESMImportedImage(originalSrc)
+	? // @ts-expect-error - clone is a private, hidden prop
+		(originalSrc.clone ?? originalSrc)
+	: originalSrc;
+
 let resultFallbackFormat = fallbackFormat ?? defaultFallbackFormat;
 if (
 	!fallbackFormat &&
-	isESMImportedImage(originalSrc) &&
-	(specialFormatsFallback as ReadonlyArray<string>).includes(originalSrc.format)
+	isESMImportedImage(clonedSrc) &&
+	(specialFormatsFallback as ReadonlyArray<string>).includes(clonedSrc.format)
 ) {
-	resultFallbackFormat = originalSrc.format;
+	resultFallbackFormat = clonedSrc.format;
 }
 
 const fallbackImage = await getImage({

package/dist/assets/consts.js

@@ -30,7 +30,8 @@ const DEFAULT_HASH_PROPS = [
   "format",
   "quality",
   "fit",
-  "position"
+  "position",
+  "background"
 ];
 export {
   DEFAULT_HASH_PROPS,

package/dist/assets/endpoint/node.js

@@ -1,21 +1,23 @@
-import { outDir } from "astro:assets";
+import { outDir, serverDir } from "astro:assets";
 import { readFile } from "node:fs/promises";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { isParentDirectory } from "@astrojs/internal-helpers/path";
 import { handleImageRequest } from "./shared.js";
 async function loadLocalImage(src, url) {
+  const outDirURL = resolveOutDir();
   const idx = url.pathname.indexOf("/_image");
   if (idx > 0) {
     src = src.slice(idx);
   }
-  if (!URL.canParse("." + src, outDir)) {
+  if (!URL.canParse("." + src, outDirURL)) {
     return void 0;
   }
-  const fileUrl = new URL("." + src, outDir);
+  const fileUrl = new URL("." + src, outDirURL);
   if (fileUrl.protocol !== "file:") {
     return void 0;
   }
-  if (!isParentDirectory(fileURLToPath(outDir), fileURLToPath(fileUrl))) {
+  if (!isParentDirectory(fileURLToPath(outDirURL), fileURLToPath(fileUrl))) {
     return void 0;
   }
   try {
@@ -34,6 +36,21 @@ const GET = async ({ request }) => {
     });
   }
 };
+function resolveOutDir() {
+  const serverDirPath = fileURLToPath(serverDir);
+  const rel = path.relative(serverDirPath, fileURLToPath(outDir));
+  const serverFolder = path.basename(serverDirPath);
+  let serverEntryFolderURL = path.dirname(import.meta.url);
+  while (!serverEntryFolderURL.endsWith(serverFolder)) {
+    serverEntryFolderURL = path.dirname(serverEntryFolderURL);
+  }
+  const serverEntryURL = serverEntryFolderURL + "/entry.mjs";
+  const outDirURL = new URL(appendForwardSlash(rel), serverEntryURL);
+  return outDirURL;
+}
+function appendForwardSlash(pth) {
+  return pth.endsWith("/") ? pth : pth + "/";
+}
 export {
   GET
 };

package/dist/assets/fonts/config.d.ts

@@ -1,80 +1,23 @@
 import * as z from 'zod/v4';
-export declare const weightSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-export declare const styleSchema: z.ZodEnum<{
+import type { FontProvider } from './types.js';
+export declare const WeightSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+export declare const StyleSchema: z.ZodEnum<{
     normal: "normal";
     italic: "italic";
     oblique: "oblique";
 }>;
-export declare const displaySchema: z.ZodEnum<{
+export declare const DisplaySchema: z.ZodEnum<{
     optional: "optional";
     auto: "auto";
     block: "block";
     swap: "swap";
     fallback: "fallback";
 }>;
-export declare const localFontFamilySchema: z.ZodObject<{
-    provider: z.ZodLiteral<"local">;
-    variants: z.ZodTuple<[z.ZodObject<{
-        src: z.ZodTuple<[z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
-            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
-            tech: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>]>], z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
-            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
-            tech: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>]>>;
-        weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        style: z.ZodOptional<z.ZodEnum<{
-            normal: "normal";
-            italic: "italic";
-            oblique: "oblique";
-        }>>;
-        display: z.ZodOptional<z.ZodEnum<{
-            optional: "optional";
-            auto: "auto";
-            block: "block";
-            swap: "swap";
-            fallback: "fallback";
-        }>>;
-        stretch: z.ZodOptional<z.ZodString>;
-        featureSettings: z.ZodOptional<z.ZodString>;
-        variationSettings: z.ZodOptional<z.ZodString>;
-        unicodeRange: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
-    }, z.core.$strict>], z.ZodObject<{
-        src: z.ZodTuple<[z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
-            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
-            tech: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>]>], z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
-            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
-            tech: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>]>>;
-        weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        style: z.ZodOptional<z.ZodEnum<{
-            normal: "normal";
-            italic: "italic";
-            oblique: "oblique";
-        }>>;
-        display: z.ZodOptional<z.ZodEnum<{
-            optional: "optional";
-            auto: "auto";
-            block: "block";
-            swap: "swap";
-            fallback: "fallback";
-        }>>;
-        stretch: z.ZodOptional<z.ZodString>;
-        featureSettings: z.ZodOptional<z.ZodString>;
-        variationSettings: z.ZodOptional<z.ZodString>;
-        unicodeRange: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
-    }, z.core.$strict>>;
-    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
+export declare const FontProviderSchema: z.ZodCustom<FontProvider<never>, FontProvider<never>>;
+export declare const FontFamilySchema: z.ZodObject<{
     name: z.ZodString;
     cssVariable: z.ZodString;
-}, z.core.$strict>;
-export declare const remoteFontFamilySchema: z.ZodObject<{
-    provider: z.ZodObject<{
-        entrypoint: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
-        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strict>;
+    provider: z.ZodCustom<FontProvider<never>, FontProvider<never>>;
     weights: z.ZodOptional<z.ZodTuple<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>], z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     styles: z.ZodOptional<z.ZodTuple<[z.ZodEnum<{
         normal: "normal";
@@ -99,6 +42,8 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         ttf: "ttf";
         eot: "eot";
     }>>>;
+    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
     display: z.ZodOptional<z.ZodEnum<{
         optional: "optional";
         auto: "auto";
@@ -110,8 +55,5 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
     featureSettings: z.ZodOptional<z.ZodString>;
     variationSettings: z.ZodOptional<z.ZodString>;
     unicodeRange: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
-    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
-    name: z.ZodString;
-    cssVariable: z.ZodString;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, z.core.$strict>;

package/dist/assets/fonts/config.js

@@ -1,62 +1,40 @@
 import * as z from "zod/v4";
-import { FONT_TYPES, LOCAL_PROVIDER_NAME } from "./constants.js";
-const weightSchema = z.union([z.string(), z.number()]);
-const styleSchema = z.enum(["normal", "italic", "oblique"]);
-const displaySchema = z.enum(["auto", "block", "swap", "fallback", "optional"]);
-const formatSchema = z.enum(FONT_TYPES);
-const familyPropertiesSchema = z.object({
-  weight: weightSchema.optional(),
-  style: styleSchema.optional(),
-  display: displaySchema.optional(),
-  stretch: z.string().optional(),
-  featureSettings: z.string().optional(),
-  variationSettings: z.string().optional(),
-  unicodeRange: z.tuple([z.string()], z.string()).optional()
-});
-const fallbacksSchema = z.object({
-  fallbacks: z.array(z.string()).optional(),
-  optimizedFallbacks: z.boolean().optional()
-});
-const requiredFamilyAttributesSchema = z.object({
+import { FONT_TYPES } from "./constants.js";
+const WeightSchema = z.union([z.string(), z.number()]);
+const StyleSchema = z.enum(["normal", "italic", "oblique"]);
+const DisplaySchema = z.enum(["auto", "block", "swap", "fallback", "optional"]);
+const FormatSchema = z.enum(FONT_TYPES);
+const _FontProviderSchema = z.strictObject({
   name: z.string(),
-  cssVariable: z.string()
+  config: z.record(z.string(), z.any()).optional(),
+  init: z.custom((v) => typeof v === "function").optional(),
+  resolveFont: z.custom((v) => typeof v === "function"),
+  listFonts: z.custom((v) => typeof v === "function").optional()
 });
-const entrypointSchema = z.union([z.string(), z.instanceof(URL)]);
-const srcSchema = z.union([
-  entrypointSchema,
-  z.object({ url: entrypointSchema, tech: z.string().optional() }).strict()
-]);
-const variantSchema = z.object({
-  ...familyPropertiesSchema.shape,
-  src: z.tuple([srcSchema], srcSchema)
-  // TODO: find a way to support subsets (through fontkit?)
-}).strict();
-const localFontFamilySchema = z.object({
-  ...requiredFamilyAttributesSchema.shape,
-  ...fallbacksSchema.shape,
-  provider: z.literal(LOCAL_PROVIDER_NAME),
-  variants: z.tuple([variantSchema], variantSchema)
-}).strict();
-const remoteFontFamilySchema = z.object({
-  ...requiredFamilyAttributesSchema.shape,
-  ...fallbacksSchema.shape,
-  ...familyPropertiesSchema.omit({
-    weight: true,
-    style: true
-  }).shape,
-  provider: z.object({
-    entrypoint: entrypointSchema,
-    config: z.record(z.string(), z.any()).optional()
-  }).strict(),
-  weights: z.tuple([weightSchema], weightSchema).optional(),
-  styles: z.tuple([styleSchema], styleSchema).optional(),
+const FontProviderSchema = z.custom((v) => {
+  return _FontProviderSchema.safeParse(v).success;
+}, "Invalid FontProvider object");
+const FontFamilySchema = z.object({
+  name: z.string(),
+  cssVariable: z.string(),
+  provider: FontProviderSchema,
+  weights: z.tuple([WeightSchema], WeightSchema).optional(),
+  styles: z.tuple([StyleSchema], StyleSchema).optional(),
   subsets: z.tuple([z.string()], z.string()).optional(),
-  formats: z.tuple([formatSchema], formatSchema).optional()
+  formats: z.tuple([FormatSchema], FormatSchema).optional(),
+  fallbacks: z.array(z.string()).optional(),
+  optimizedFallbacks: z.boolean().optional(),
+  display: DisplaySchema.optional(),
+  stretch: z.string().optional(),
+  featureSettings: z.string().optional(),
+  variationSettings: z.string().optional(),
+  unicodeRange: z.tuple([z.string()], z.string()).optional(),
+  options: z.record(z.string(), z.any()).optional()
 }).strict();
 export {
-  displaySchema,
-  localFontFamilySchema,
-  remoteFontFamilySchema,
-  styleSchema,
-  weightSchema
+  DisplaySchema,
+  FontFamilySchema,
+  FontProviderSchema,
+  StyleSchema,
+  WeightSchema
 };

package/dist/assets/fonts/constants.d.ts

@@ -1,9 +1,9 @@
 import type { Defaults, FontType } from './types.js';
-export declare const LOCAL_PROVIDER_NAME = "local";
 export declare const DEFAULTS: Defaults;
-/** Used to serialize data, to be used by public APIs */
 export declare const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
+export declare const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime";
+export declare const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID: string;
 export declare const ASSETS_DIR = "fonts";
 export declare const CACHE_DIR = "./fonts/";
 export declare const FONT_TYPES: readonly ["woff2", "woff", "otf", "ttf", "eot"];

package/dist/assets/fonts/constants.js

@@ -1,4 +1,3 @@
-const LOCAL_PROVIDER_NAME = "local";
 const DEFAULTS = {
   weights: ["400"],
   styles: ["normal", "italic"],
@@ -10,6 +9,8 @@ const DEFAULTS = {
 };
 const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime";
+const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID = "\0" + RUNTIME_VIRTUAL_MODULE_ID;
 const ASSETS_DIR = "fonts";
 const CACHE_DIR = "./fonts/";
 const FONT_TYPES = ["woff2", "woff", "otf", "ttf", "eot"];
@@ -44,7 +45,8 @@ export {
   FONT_FORMATS,
   FONT_TYPES,
   GENERIC_FALLBACK_NAMES,
-  LOCAL_PROVIDER_NAME,
+  RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
+  RUNTIME_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 };

package/dist/assets/fonts/core/collect-component-data.d.ts

@@ -0,0 +1,9 @@
+import type { CssRenderer } from '../definitions.js';
+import type { Collaborator, ComponentDataByCssVariable, Defaults, FontFamilyAssets } from '../types.js';
+import type { optimizeFallbacks as _optimizeFallbacks } from './optimize-fallbacks.js';
+export declare function collectComponentData({ fontFamilyAssets, cssRenderer, defaults, optimizeFallbacks, }: {
+    fontFamilyAssets: Array<FontFamilyAssets>;
+    cssRenderer: CssRenderer;
+    defaults: Pick<Defaults, 'fallbacks' | 'optimizedFallbacks'>;
+    optimizeFallbacks: Collaborator<typeof _optimizeFallbacks, 'family' | 'fallbacks' | 'collectedFonts'>;
+}): Promise<ComponentDataByCssVariable>;

package/dist/assets/fonts/core/collect-component-data.js

@@ -0,0 +1,47 @@
+import { unifontFontFaceDataToProperties } from "../utils.js";
+async function collectComponentData({
+  fontFamilyAssets,
+  cssRenderer,
+  defaults,
+  optimizeFallbacks
+}) {
+  const componentDataByCssVariable = /* @__PURE__ */ new Map();
+  for (const { family, fonts, collectedFontsForMetricsByUniqueKey, preloads } of fontFamilyAssets) {
+    let css = "";
+    for (const data of fonts) {
+      css += cssRenderer.generateFontFace(
+        family.uniqueName,
+        unifontFontFaceDataToProperties({
+          src: data.src,
+          weight: data.weight,
+          style: data.style,
+          // User settings override the generated font settings
+          display: data.display ?? family.display,
+          unicodeRange: data.unicodeRange ?? family.unicodeRange,
+          stretch: data.stretch ?? family.stretch,
+          featureSettings: data.featureSettings ?? family.featureSettings,
+          variationSettings: data.variationSettings ?? family.variationSettings
+        })
+      );
+    }
+    const fallbacks = family.fallbacks ?? defaults.fallbacks;
+    const cssVarValues = [family.uniqueName];
+    const optimizeFallbacksResult = family.optimizedFallbacks ?? defaults.optimizedFallbacks ? await optimizeFallbacks({
+      family,
+      fallbacks,
+      collectedFonts: Array.from(collectedFontsForMetricsByUniqueKey.values())
+    }) : null;
+    if (optimizeFallbacksResult) {
+      css += optimizeFallbacksResult.css;
+      cssVarValues.push(...optimizeFallbacksResult.fallbacks);
+    } else {
+      cssVarValues.push(...fallbacks);
+    }
+    css += cssRenderer.generateCssVariable(family.cssVariable, cssVarValues);
+    componentDataByCssVariable.set(family.cssVariable, { preloads, css });
+  }
+  return componentDataByCssVariable;
+}
+export {
+  collectComponentData
+};

package/dist/assets/fonts/core/collect-font-assets-from-faces.d.ts

@@ -0,0 +1,17 @@
+import type * as unifont from 'unifont';
+import type { FontFileIdGenerator, Hasher } from '../definitions.js';
+import type { Defaults, FontFileById, PreloadData, ResolvedFontFamily } from '../types.js';
+import type { CollectedFontForMetrics } from './optimize-fallbacks.js';
+export declare function collectFontAssetsFromFaces({ fonts, fontFileIdGenerator, family, fontFilesIds, collectedFontsIds, hasher, defaults, }: {
+    fonts: Array<unifont.FontFaceData>;
+    fontFileIdGenerator: FontFileIdGenerator;
+    family: Pick<ResolvedFontFamily, 'cssVariable' | 'fallbacks'>;
+    fontFilesIds: Set<string>;
+    collectedFontsIds: Set<string>;
+    hasher: Hasher;
+    defaults: Pick<Defaults, 'fallbacks'>;
+}): {
+    fontFileById: FontFileById;
+    preloads: PreloadData[];
+    collectedFontsForMetricsByUniqueKey: Map<string, CollectedFontForMetrics>;
+};

package/dist/assets/fonts/core/collect-font-assets-from-faces.js

@@ -0,0 +1,71 @@
+import { FONT_FORMATS } from "../constants.js";
+import { renderFontWeight } from "../utils.js";
+function collectFontAssetsFromFaces({
+  fonts,
+  fontFileIdGenerator,
+  family,
+  fontFilesIds,
+  collectedFontsIds,
+  hasher,
+  defaults
+}) {
+  const fontFileById = /* @__PURE__ */ new Map();
+  const collectedFontsForMetricsByUniqueKey = /* @__PURE__ */ new Map();
+  const preloads = [];
+  for (const font of fonts) {
+    let index = 0;
+    for (const source of font.src) {
+      if ("name" in source) {
+        continue;
+      }
+      const format = FONT_FORMATS.find((e) => e.format === source.format);
+      const originalUrl = source.originalURL;
+      const id = fontFileIdGenerator.generate({
+        cssVariable: family.cssVariable,
+        font,
+        originalUrl,
+        type: format.type
+      });
+      if (!fontFilesIds.has(id) && !fontFileById.has(id)) {
+        fontFileById.set(id, { url: originalUrl, init: font.meta?.init });
+        if (index === 0) {
+          preloads.push({
+            style: font.style,
+            subset: font.meta?.subset,
+            type: format.type,
+            url: source.url,
+            weight: renderFontWeight(font.weight)
+          });
+        }
+      }
+      const collected = {
+        id,
+        url: originalUrl,
+        init: font.meta?.init,
+        data: {
+          weight: font.weight,
+          style: font.style,
+          meta: {
+            subset: font.meta?.subset
+          }
+        }
+      };
+      const collectedKey = hasher.hashObject(collected.data);
+      const fallbacks = family.fallbacks ?? defaults.fallbacks;
+      if (fallbacks.length > 0 && // If the same data has already been sent for this family, we don't want to have
+      // duplicated fallbacks. Such scenario can occur with unicode ranges.
+      !collectedFontsIds.has(collectedKey) && !collectedFontsForMetricsByUniqueKey.has(collectedKey)) {
+        collectedFontsForMetricsByUniqueKey.set(collectedKey, collected);
+      }
+      index++;
+    }
+  }
+  return {
+    fontFileById,
+    preloads,
+    collectedFontsForMetricsByUniqueKey
+  };
+}
+export {
+  collectFontAssetsFromFaces
+};

package/dist/assets/fonts/core/collect-font-data.d.ts

@@ -0,0 +1,4 @@
+import type { FontDataByCssVariable, FontFamilyAssets } from '../types.js';
+export declare function collectFontData(fontFamilyAssets: Array<Pick<FontFamilyAssets, 'fonts'> & {
+    family: Pick<FontFamilyAssets['family'], 'cssVariable'>;
+}>): FontDataByCssVariable;

package/dist/assets/fonts/core/collect-font-data.js

@@ -0,0 +1,23 @@
+import { renderFontWeight } from "../utils.js";
+function collectFontData(fontFamilyAssets) {
+  const fontDataByCssVariable = {};
+  for (const { family, fonts } of fontFamilyAssets) {
+    const fontData = [];
+    for (const data of fonts) {
+      fontData.push({
+        weight: renderFontWeight(data.weight),
+        style: data.style,
+        src: data.src.filter((src) => "url" in src).map((src) => ({
+          url: src.url,
+          format: src.format,
+          tech: src.tech
+        }))
+      });
+    }
+    fontDataByCssVariable[family.cssVariable] = fontData;
+  }
+  return fontDataByCssVariable;
+}
+export {
+  collectFontData
+};

package/dist/assets/fonts/core/compute-font-families-assets.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '../../../core/logger/core.js';
+import type { FontResolver, StringMatcher } from '../definitions.js';
+import type { Collaborator, Defaults, FontFileById, ResolvedFontFamily } from '../types.js';
+import type { collectFontAssetsFromFaces as _collectFontAssetsFromFaces } from './collect-font-assets-from-faces.js';
+import type { filterAndTransformFontFaces as _filterAndTransformFontFaces } from './filter-and-transform-font-faces.js';
+import type { getOrCreateFontFamilyAssets as _getOrCreateFontFamilyAssets } from './get-or-create-font-family-assets.js';
+export declare function computeFontFamiliesAssets({ resolvedFamilies, fontResolver, logger, bold, defaults, stringMatcher, getOrCreateFontFamilyAssets, collectFontAssetsFromFaces, filterAndTransformFontFaces, }: {
+    resolvedFamilies: Array<ResolvedFontFamily>;
+    fontResolver: FontResolver;
+    logger: Logger;
+    bold: (input: string) => string;
+    defaults: Defaults;
+    stringMatcher: StringMatcher;
+    getOrCreateFontFamilyAssets: Collaborator<typeof _getOrCreateFontFamilyAssets, 'family' | 'fontFamilyAssetsByUniqueKey'>;
+    filterAndTransformFontFaces: Collaborator<typeof _filterAndTransformFontFaces, 'family' | 'fonts'>;
+    collectFontAssetsFromFaces: Collaborator<typeof _collectFontAssetsFromFaces, 'family' | 'fonts' | 'collectedFontsIds' | 'fontFilesIds'>;
+}): Promise<{
+    fontFamilyAssets: import("../types.js").FontFamilyAssets[];
+    fontFileById: FontFileById;
+}>;