astro 6.0.0-beta.2 → 6.0.0-beta.4

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/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

@@ -4,8 +4,8 @@ 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) {
+const { componentDataByCssVariable } = mod;
+if (!componentDataByCssVariable) {
 	throw new AstroError(AstroErrorData.ExperimentalFontsNotEnabled);
 }
 
@@ -17,7 +17,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 +25,7 @@ if (!data) {
 	});
 }
 
-const filteredPreloadData = filterPreloads(data.preloadData, preload);
+const filteredPreloadData = filterPreloads(data.preloads, preload);
 ---
 
 <style set:html={data.css}></style>

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

@@ -1,107 +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 fontProviderSchema: z.ZodObject<{
-    name: z.ZodString;
-    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    init: z.ZodOptional<z.ZodCustom<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
-    resolveFont: z.ZodCustom<(options: import("./types.js").ResolveFontOptions<never>) => {
-        fonts: Array<import("unifont").FontFaceData>;
-    } | Promise<{
-        fonts: Array<import("unifont").FontFaceData>;
-    } | undefined> | undefined, (options: import("./types.js").ResolveFontOptions<never>) => {
-        fonts: Array<import("unifont").FontFaceData>;
-    } | Promise<{
-        fonts: Array<import("unifont").FontFaceData>;
-    } | undefined> | undefined>;
-    listFonts: z.ZodOptional<z.ZodCustom<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
-}, z.core.$strict>;
-export declare const remoteFontFamilySchema: z.ZodObject<{
-    provider: z.ZodObject<{
-        name: z.ZodString;
-        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        init: z.ZodOptional<z.ZodCustom<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
-        resolveFont: z.ZodCustom<(options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined, (options: import("./types.js").ResolveFontOptions<never>) => {
-            fonts: Array<import("unifont").FontFaceData>;
-        } | Promise<{
-            fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined>;
-        listFonts: z.ZodOptional<z.ZodCustom<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
-    }, z.core.$strict>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    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";
@@ -126,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";
@@ -137,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,68 +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({
-  name: z.string(),
-  cssVariable: z.string()
-});
-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 fontProviderSchema = 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(),
   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()
-}).strict();
-const remoteFontFamilySchema = z.object({
-  ...requiredFamilyAttributesSchema.shape,
-  ...fallbacksSchema.shape,
-  ...familyPropertiesSchema.omit({
-    weight: true,
-    style: true
-  }).shape,
-  provider: fontProviderSchema,
-  options: z.record(z.string(), z.any()).optional(),
-  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,
-  fontProviderSchema,
-  localFontFamilySchema,
-  remoteFontFamilySchema,
-  styleSchema,
-  weightSchema
+  DisplaySchema,
+  FontFamilySchema,
+  FontProviderSchema,
+  StyleSchema,
+  WeightSchema
 };

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

@@ -1,5 +1,4 @@
 import type { Defaults, FontType } from './types.js';
-export declare const LOCAL_PROVIDER_NAME = "local";
 export declare const DEFAULTS: Defaults;
 export declare const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;

package/dist/assets/fonts/constants.js

@@ -1,4 +1,3 @@
-const LOCAL_PROVIDER_NAME = "local";
 const DEFAULTS = {
   weights: ["400"],
   styles: ["normal", "italic"],
@@ -49,7 +48,6 @@ export {
   FONT_FORMATS,
   FONT_TYPES,
   GENERIC_FALLBACK_NAMES,
-  LOCAL_PROVIDER_NAME,
   RESOLVED_BUFFER_VIRTUAL_MODULE_ID_PREFIX,
   RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_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;
+}>;

package/dist/assets/fonts/core/compute-font-families-assets.js

@@ -0,0 +1,67 @@
+async function computeFontFamiliesAssets({
+  resolvedFamilies,
+  fontResolver,
+  logger,
+  bold,
+  defaults,
+  stringMatcher,
+  getOrCreateFontFamilyAssets,
+  collectFontAssetsFromFaces,
+  filterAndTransformFontFaces
+}) {
+  const fontFamilyAssetsByUniqueKey = /* @__PURE__ */ new Map();
+  const fontFileById = /* @__PURE__ */ new Map();
+  for (const family of resolvedFamilies) {
+    const fontAssets = getOrCreateFontFamilyAssets({
+      fontFamilyAssetsByUniqueKey,
+      family
+    });
+    const _fonts = await fontResolver.resolveFont({
+      familyName: family.name,
+      provider: family.provider,
+      // We do not merge the defaults, we only provide defaults as a fallback
+      weights: family.weights ?? defaults.weights,
+      styles: family.styles ?? defaults.styles,
+      subsets: family.subsets ?? defaults.subsets,
+      formats: family.formats ?? defaults.formats,
+      options: family.options
+    });
+    if (_fonts.length === 0) {
+      logger.warn(
+        "assets",
+        `No data found for font family ${bold(family.name)}. Review your configuration`
+      );
+      const availableFamilies = await fontResolver.listFonts({ provider: family.provider });
+      if (availableFamilies && availableFamilies.length > 0 && !availableFamilies.includes(family.name)) {
+        logger.warn(
+          "assets",
+          `${bold(family.name)} font family cannot be retrieved by the provider. Did you mean ${bold(stringMatcher.getClosestMatch(family.name, availableFamilies))}?`
+        );
+      }
+      continue;
+    }
+    fontAssets.fonts.push(
+      ...filterAndTransformFontFaces({
+        fonts: _fonts,
+        family
+      })
+    );
+    const result = collectFontAssetsFromFaces({
+      fonts: fontAssets.fonts,
+      family,
+      fontFilesIds: new Set(fontFileById.keys()),
+      collectedFontsIds: new Set(fontAssets.collectedFontsForMetricsByUniqueKey.keys())
+    });
+    for (const [key, value] of result.fontFileById.entries()) {
+      fontFileById.set(key, value);
+    }
+    for (const [key, value] of result.collectedFontsForMetricsByUniqueKey.entries()) {
+      fontAssets.collectedFontsForMetricsByUniqueKey.set(key, value);
+    }
+    fontAssets.preloads.push(...result.preloads);
+  }
+  return { fontFamilyAssets: Array.from(fontFamilyAssetsByUniqueKey.values()), fontFileById };
+}
+export {
+  computeFontFamiliesAssets
+};

package/dist/assets/fonts/core/filter-and-transform-font-faces.d.ts

@@ -0,0 +1,20 @@
+import type * as unifont from 'unifont';
+import type { FontFileIdGenerator, FontTypeExtractor, UrlResolver } from '../definitions.js';
+import type { ResolvedFontFamily } from '../types.js';
+export declare function filterAndTransformFontFaces({ fonts, fontTypeExtractor, fontFileIdGenerator, urlResolver, family, }: {
+    fonts: Array<unifont.FontFaceData>;
+    fontTypeExtractor: FontTypeExtractor;
+    fontFileIdGenerator: FontFileIdGenerator;
+    urlResolver: UrlResolver;
+    family: Pick<ResolvedFontFamily, 'cssVariable'>;
+}): {
+    src: (unifont.LocalFontSource | unifont.RemoteFontSource)[];
+    display?: "auto" | "block" | "swap" | "fallback" | "optional";
+    weight?: string | number | [number, number];
+    stretch?: string;
+    style?: string;
+    unicodeRange?: string[];
+    featureSettings?: string;
+    variationSettings?: string;
+    meta?: unifont.FontFaceMeta;
+}[];

package/dist/assets/fonts/core/filter-and-transform-font-faces.js

@@ -0,0 +1,39 @@
+import { FONT_FORMATS } from "../constants.js";
+function filterAndTransformFontFaces({
+  fonts,
+  fontTypeExtractor,
+  fontFileIdGenerator,
+  urlResolver,
+  family
+}) {
+  return fonts.filter((font) => typeof font.meta?.priority === "number" ? font.meta.priority <= 1 : true).map((font) => ({
+    ...font,
+    src: font.src.map((source) => {
+      if ("name" in source) {
+        return source;
+      }
+      const originalUrl = source.url.startsWith("//") ? `https:${source.url}` : source.url;
+      let format = FONT_FORMATS.find((e) => e.format === source.format);
+      if (!format) {
+        format = FONT_FORMATS.find((e) => e.type === fontTypeExtractor.extract(source.url));
+      }
+      const id = fontFileIdGenerator.generate({
+        cssVariable: family.cssVariable,
+        font,
+        originalUrl,
+        type: format.type
+      });
+      const url = urlResolver.resolve(id);
+      const newSource = {
+        originalURL: originalUrl,
+        url,
+        format: format.format,
+        tech: source.tech
+      };
+      return newSource;
+    })
+  }));
+}
+export {
+  filterAndTransformFontFaces
+};

package/dist/assets/fonts/core/get-or-create-font-family-assets.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from '../../../core/logger/core.js';
+import type { FontFamilyAssetsByUniqueKey, ResolvedFontFamily } from '../types.js';
+export declare function getOrCreateFontFamilyAssets({ fontFamilyAssetsByUniqueKey, logger, bold, family, }: {
+    fontFamilyAssetsByUniqueKey: FontFamilyAssetsByUniqueKey;
+    logger: Logger;
+    bold: (input: string) => string;
+    family: ResolvedFontFamily;
+}): import("../types.js").FontFamilyAssets;