astro 6.0.0-beta.1 → 6.0.0-beta.2

package/dist/assets/fonts/orchestrate.js

@@ -11,7 +11,6 @@ import {
 async function orchestrate({
   families,
   hasher,
-  remoteFontProviderResolver,
   localProviderUrlResolver,
   cssRenderer,
   systemFallbacksProvider,
@@ -25,16 +24,15 @@ async function orchestrate({
   stringMatcher,
   createFontResolver
 }) {
-  const resolvedFamilies = await resolveFamilies({
+  const resolvedFamilies = resolveFamilies({
     families,
     hasher,
-    remoteFontProviderResolver,
     localProviderUrlResolver
   });
   const fontResolver = await createFontResolver({ families: resolvedFamilies });
   const fontFileDataMap = /* @__PURE__ */ new Map();
   const internalConsumableMap = /* @__PURE__ */ new Map();
-  const consumableMap = /* @__PURE__ */ new Map();
+  const fontData = {};
   const resolvedFamiliesMap = /* @__PURE__ */ new Map();
   for (const family of resolvedFamilies) {
     const key = `${family.cssVariable}:${family.name}:${typeof family.provider === "string" ? family.provider : family.provider.name}`;
@@ -80,32 +78,30 @@ async function orchestrate({
       cssVariable: family.cssVariable
     });
     if (family.provider === LOCAL_PROVIDER_NAME) {
-      const result = resolveLocalFont({
+      const fonts = resolveLocalFont({
         family,
         urlProxy,
         fontTypeExtractor,
         fontFileReader
       });
-      resolvedFamily.fonts.push(...result.fonts);
+      resolvedFamily.fonts.push(...fonts);
     } else {
       const fonts = await fontResolver.resolveFont({
         familyName: family.name,
-        // By default, unifont goes through all providers. We use a different approach where
-        // we specify a provider per font. Name has been set while extracting unifont providers
-        // from families (inside extractUnifontProviders).
-        provider: family.provider.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
+        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.name });
+        const availableFamilies = await fontResolver.listFonts({ provider: family.provider });
         if (availableFamilies && availableFamilies.length > 0 && !availableFamilies.includes(family.name)) {
           logger.warn(
             "assets",
@@ -123,7 +119,7 @@ async function orchestrate({
     collectedFonts,
     preloadData
   } of resolvedFamiliesMap.values()) {
-    const consumableMapValue = [];
+    const fontDataValue = [];
     let css = "";
     for (const data of fonts) {
       css += cssRenderer.generateFontFace(
@@ -141,7 +137,7 @@ async function orchestrate({
           variationSettings: pickFontFaceProperty("variationSettings", { data, family })
         })
       );
-      consumableMapValue.push({
+      fontDataValue.push({
         weight: renderFontWeight(data.weight),
         style: data.style,
         src: data.src.filter((src) => "url" in src).map((src) => ({
@@ -168,9 +164,9 @@ async function orchestrate({
     }
     css += cssRenderer.generateCssVariable(family.cssVariable, cssVarValues);
     internalConsumableMap.set(family.cssVariable, { preloadData, css });
-    consumableMap.set(family.cssVariable, consumableMapValue);
+    fontData[family.cssVariable] = fontDataValue;
   }
-  return { fontFileDataMap, internalConsumableMap, consumableMap };
+  return { fontFileDataMap, internalConsumableMap, fontData };
 }
 export {
   orchestrate

package/dist/assets/fonts/providers/index.d.ts

@@ -1,7 +1,7 @@
-import type { providers } from 'unifont';
+import { type AdobeProviderOptions, type GoogleFamilyOptions, type GoogleiconsFamilyOptions } from 'unifont';
 import type { FontProvider } from '../types.js';
 /** [Adobe](https://fonts.adobe.com/) */
-declare function adobe(config: Parameters<typeof providers.adobe>[0]): FontProvider;
+declare function adobe(config: AdobeProviderOptions): FontProvider;
 /** [Bunny](https://fonts.bunny.net/) */
 declare function bunny(): FontProvider;
 /** [Fontshare](https://www.fontshare.com/) */
@@ -9,7 +9,9 @@ declare function fontshare(): FontProvider;
 /** [Fontsource](https://fontsource.org/) */
 declare function fontsource(): FontProvider;
 /** [Google](https://fonts.google.com/) */
-declare function google(config?: Parameters<typeof providers.google>[0]): FontProvider;
+declare function google(): FontProvider<GoogleFamilyOptions | undefined>;
+/** [Google Icons](https://fonts.google.com/icons) */
+declare function googleicons(): FontProvider<GoogleiconsFamilyOptions | undefined>;
 /**
  * Astro re-exports most [unifont](https://github.com/unjs/unifont/) providers:
  * - [Adobe](https://fonts.adobe.com/)
@@ -17,6 +19,7 @@ declare function google(config?: Parameters<typeof providers.google>[0]): FontPr
  * - [Fontshare](https://www.fontshare.com/)
  * - [Fontsource](https://fontsource.org/)
  * - [Google](https://fonts.google.com/)
+ * - [Google Icons](https://fonts.google.com/icons)
  */
 export declare const fontProviders: {
     adobe: typeof adobe;
@@ -24,5 +27,6 @@ export declare const fontProviders: {
     fontshare: typeof fontshare;
     fontsource: typeof fontsource;
     google: typeof google;
+    googleicons: typeof googleicons;
 };
 export {};

package/dist/assets/fonts/providers/index.js

@@ -1,28 +1,101 @@
+import {
+  providers
+} from "unifont";
 function adobe(config) {
+  const provider = providers.adobe(config);
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/adobe",
-    config
+    name: provider._name,
+    config,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 function bunny() {
+  const provider = providers.bunny();
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/bunny"
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 function fontshare() {
+  const provider = providers.fontshare();
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/fontshare"
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 function fontsource() {
+  const provider = providers.fontsource();
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/fontsource"
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
-function google(config) {
+function google() {
+  const provider = providers.google();
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/google",
-    config
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
+  };
+}
+function googleicons() {
+  const provider = providers.googleicons();
+  let initializedProvider;
+  return {
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 const fontProviders = {
@@ -30,7 +103,8 @@ const fontProviders = {
   bunny,
   fontshare,
   fontsource,
-  google
+  google,
+  googleicons
 };
 export {
   fontProviders

package/dist/assets/fonts/providers/local.d.ts

@@ -7,7 +7,5 @@ interface Options {
     fontTypeExtractor: FontTypeExtractor;
     fontFileReader: FontFileReader;
 }
-export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor, fontFileReader, }: Options): {
-    fonts: Array<unifont.FontFaceData>;
-};
+export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor, fontFileReader, }: Options): Array<unifont.FontFaceData>;
 export {};

package/dist/assets/fonts/providers/local.js

@@ -5,49 +5,47 @@ function resolveLocalFont({
   fontTypeExtractor,
   fontFileReader
 }) {
-  return {
-    fonts: family.variants.map((variant) => {
-      const shouldInfer = variant.weight === void 0 || variant.style === void 0;
-      const data = {
-        // If it should be inferred, we don't want to set the value
-        weight: variant.weight,
-        style: variant.style,
-        src: [],
-        unicodeRange: variant.unicodeRange,
-        display: variant.display,
-        stretch: variant.stretch,
-        featureSettings: variant.featureSettings,
-        variationSettings: variant.variationSettings
+  return family.variants.map((variant) => {
+    const shouldInfer = variant.weight === void 0 || variant.style === void 0;
+    const data = {
+      // If it should be inferred, we don't want to set the value
+      weight: variant.weight,
+      style: variant.style,
+      src: [],
+      unicodeRange: variant.unicodeRange,
+      display: variant.display,
+      stretch: variant.stretch,
+      featureSettings: variant.featureSettings,
+      variationSettings: variant.variationSettings
+    };
+    data.src = variant.src.map((source, index) => {
+      if (shouldInfer && index === 0) {
+        const result = fontFileReader.extract({ family: family.name, url: source.url });
+        if (variant.weight === void 0) data.weight = result.weight;
+        if (variant.style === void 0) data.style = result.style;
+      }
+      const type = fontTypeExtractor.extract(source.url);
+      return {
+        originalURL: source.url,
+        url: urlProxy.proxy({
+          url: source.url,
+          type,
+          // We only use the first source for preloading. For example if woff2 and woff
+          // are available, we only keep woff2.
+          collectPreload: index === 0,
+          data: {
+            weight: data.weight,
+            style: data.style,
+            subset: void 0
+          },
+          init: null
+        }),
+        format: FONT_FORMATS.find((e) => e.type === type)?.format,
+        tech: source.tech
       };
-      data.src = variant.src.map((source, index) => {
-        if (shouldInfer && index === 0) {
-          const result = fontFileReader.extract({ family: family.name, url: source.url });
-          if (variant.weight === void 0) data.weight = result.weight;
-          if (variant.style === void 0) data.style = result.style;
-        }
-        const type = fontTypeExtractor.extract(source.url);
-        return {
-          originalURL: source.url,
-          url: urlProxy.proxy({
-            url: source.url,
-            type,
-            // We only use the first source for preloading. For example if woff2 and woff
-            // are available, we only keep woff2.
-            collectPreload: index === 0,
-            data: {
-              weight: data.weight,
-              style: data.style,
-              subset: void 0
-            },
-            init: null
-          }),
-          format: FONT_FORMATS.find((e) => e.type === type)?.format,
-          tech: source.tech
-        };
-      });
-      return data;
-    })
-  };
+    });
+    return data;
+  });
 }
 export {
   resolveLocalFont

package/dist/assets/fonts/runtime/client.d.ts

@@ -0,0 +1,2 @@
+export declare const fontData: import("../types.js").FontDataRecord;
+export declare function getFontBuffer(): Promise<void>;

package/dist/assets/fonts/runtime/client.js

@@ -0,0 +1,9 @@
+import * as fontsMod from "virtual:astro:assets/fonts/internal";
+const fontData = fontsMod.fontData ?? {};
+async function getFontBuffer() {
+  throw new Error("[astro:assets] `getFontBuffer()` is not available on the client.");
+}
+export {
+  fontData,
+  getFontBuffer
+};

package/dist/assets/fonts/runtime/server.d.ts

@@ -0,0 +1,2 @@
+export declare const fontData: import("../types.js").FontDataRecord;
+export declare const getFontBuffer: (url: string) => Promise<Buffer<ArrayBufferLike>>;

package/dist/assets/fonts/runtime/server.js

@@ -0,0 +1,8 @@
+import * as fontsMod from "virtual:astro:assets/fonts/internal";
+import { createGetFontBuffer } from "../core/create-get-font-buffer.js";
+const fontData = fontsMod.fontData ?? {};
+const getFontBuffer = createGetFontBuffer(fontsMod);
+export {
+  fontData,
+  getFontBuffer
+};

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

@@ -6,15 +6,40 @@ import type { FONT_TYPES, GENERIC_FALLBACK_NAMES, LOCAL_PROVIDER_NAME } from './
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
 type Weight = z.infer<typeof weightSchema>;
 type Display = z.infer<typeof displaySchema>;
-export interface FontProvider {
+/** @lintignore */
+export interface FontProviderInitContext {
+    storage: {
+        getItem: {
+            <T = unknown>(key: string): Promise<T | null>;
+            <T = unknown>(key: string, init: () => Awaitable<T>): Promise<T>;
+        };
+        setItem: (key: string, value: unknown) => Awaitable<void>;
+    };
+}
+type Awaitable<T> = T | Promise<T>;
+export interface FontProvider<TFamilyOptions extends Record<string, any> | undefined | never = never> {
     /**
-     * URL, path relative to the root or package import.
+     * The font provider name, used for display and deduplication.
      */
-    entrypoint: string | URL;
+    name: string;
     /**
-     * Optional serializable object passed to the unifont provider.
+     * Optional serializable object, used for deduplication.
      */
     config?: Record<string, any> | undefined;
+    /**
+     * Optional callback, used to perform any initialization logic.
+     */
+    init?: ((context: FontProviderInitContext) => Awaitable<void>) | undefined;
+    /**
+     * Required callback, used to retrieve and return font face data based on the given options.
+     */
+    resolveFont: (options: ResolveFontOptions<TFamilyOptions>) => Awaitable<{
+        fonts: Array<unifont.FontFaceData>;
+    } | undefined>;
+    /**
+     * Optional callback, used to return the list of available font names.
+     */
+    listFonts?: (() => Awaitable<Array<string> | undefined>) | undefined;
 }
 interface RequiredFamilyAttributes {
     /**
@@ -89,11 +114,6 @@ interface FamilyProperties {
      */
     unicodeRange?: [string, ...Array<string>] | undefined;
 }
-export interface ResolvedFontProvider {
-    name?: string;
-    provider: (config?: Record<string, any>) => unifont.Provider;
-    config?: Record<string, any>;
-}
 type Src = string | URL | {
     url: string | URL;
     tech?: string | undefined;
@@ -126,11 +146,32 @@ export interface ResolvedLocalFontFamily extends ResolvedFontFamilyAttributes, O
         }>;
     }>;
 }
-export interface RemoteFontFamily extends RequiredFamilyAttributes, Omit<FamilyProperties, 'weight' | 'style' | 'subsets' | 'formats'>, Fallbacks {
+type WithOptions<TFontProvider extends FontProvider> = TFontProvider extends FontProvider<infer TFamilyOptions> ? [TFamilyOptions] extends [never] ? {
+    /**
+     * Options forwarded to the font provider while resolving this font family.
+     */
+    options?: undefined;
+} : undefined extends TFamilyOptions ? {
+    /**
+     * Options forwarded to the font provider while resolving this font family.
+     */
+    options?: TFamilyOptions;
+} : {
+    /**
+     * Options forwarded to the font provider while resolving this font family.
+     */
+    options: TFamilyOptions;
+} : {
+    /**
+     * Options forwarded to the font provider while resolving this font family.
+     */
+    options?: undefined;
+};
+export type RemoteFontFamily<TFontProvider extends FontProvider = FontProvider> = RequiredFamilyAttributes & Omit<FamilyProperties, 'weight' | 'style' | 'subsets' | 'formats'> & Fallbacks & WithOptions<NoInfer<TFontProvider>> & {
     /**
      * The source of your font files. You can use a built-in provider or write your own custom provider.
      */
-    provider: FontProvider;
+    provider: TFontProvider;
     /**
      * @default `[400]`
      *
@@ -159,13 +200,12 @@ export interface RemoteFontFamily extends RequiredFamilyAttributes, Omit<FamilyP
      * An array of [font formats](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@font-face/src#font_formats).
      */
     formats?: [FontType, ...Array<FontType>] | undefined;
-}
+};
 /** @lintignore somehow required by pickFontFaceProperty in utils */
-export interface ResolvedRemoteFontFamily extends ResolvedFontFamilyAttributes, Omit<RemoteFontFamily, 'provider' | 'weights'> {
-    provider: ResolvedFontProvider;
+export interface ResolvedRemoteFontFamily extends ResolvedFontFamilyAttributes, Omit<RemoteFontFamily, 'weights'> {
     weights?: Array<string>;
 }
-export type FontFamily = LocalFontFamily | RemoteFontFamily;
+export type FontFamily<TFontProvider extends FontProvider = FontProvider> = LocalFontFamily | RemoteFontFamily<TFontProvider>;
 export type ResolvedFontFamily = ResolvedLocalFontFamily | ResolvedRemoteFontFamily;
 export type FontType = (typeof FONT_TYPES)[number];
 /**
@@ -186,7 +226,7 @@ export interface PreloadData {
 }
 export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
 export type GenericFallbackName = (typeof GENERIC_FALLBACK_NAMES)[number];
-export type Defaults = Partial<Pick<ResolvedRemoteFontFamily, 'weights' | 'styles' | 'subsets' | 'fallbacks' | 'optimizedFallbacks' | 'formats'>>;
+export type Defaults = Required<Pick<ResolvedRemoteFontFamily, 'weights' | 'styles' | 'subsets' | 'fallbacks' | 'optimizedFallbacks' | 'formats'>>;
 export interface FontFileData {
     hash: string;
     url: string;
@@ -224,18 +264,22 @@ export interface FontData {
 /**
  * Holds associations of CSS variables and font data to be exposed via virtual module.
  */
-export type ConsumableMap = Map<string, Array<FontData>>;
+export type FontDataRecord = Record<string, Array<FontData>>;
 export type Style = z.output<typeof styleSchema>;
 export type PreloadFilter = boolean | Array<{
     weight?: string | number;
     style?: string;
     subset?: string;
 }>;
-export interface AstroFontProviderResolveFontOptions {
+export interface ResolveFontOptions<FamilyOptions extends Record<string, any> | undefined | never = never> {
     familyName: string;
-    weights: string[] | undefined;
-    styles: Style[] | undefined;
-    subsets: string[] | undefined;
-    formats: FontType[] | undefined;
+    weights: string[];
+    styles: Style[];
+    subsets: string[];
+    formats: FontType[];
+    options: [FamilyOptions] extends [never] ? undefined : FamilyOptions | undefined;
 }
+export type BufferImports = Record<string, () => Promise<{
+    default: Buffer | null;
+}>>;
 export {};

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

@@ -20,7 +20,6 @@ export declare function cache(storage: Storage, key: string, cb: () => Promise<B
 export declare function isGenericFontFamily(str: string): str is GenericFallbackName;
 export declare function dedupe<const T extends Array<any>>(arr: T): T;
 export declare function sortObjectByKey<T extends Record<string, any>>(unordered: T): T;
-export declare function resolveEntrypoint(root: URL, entrypoint: string): URL;
 export declare function pickFontFaceProperty<T extends keyof Pick<unifont.FontFaceData, 'display' | 'unicodeRange' | 'stretch' | 'featureSettings' | 'variationSettings'>>(property: T, { data, family }: {
     data: unifont.FontFaceData;
     family: ResolvedFontFamily;

package/dist/assets/fonts/utils.js

@@ -1,5 +1,3 @@
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
 import { FONT_TYPES, GENERIC_FALLBACK_NAMES, LOCAL_PROVIDER_NAME } from "./constants.js";
 function unifontFontFaceDataToProperties(font) {
   return {
@@ -61,14 +59,6 @@ function sortObjectByKey(unordered) {
   }, {});
   return ordered;
 }
-function resolveEntrypoint(root, entrypoint) {
-  const require2 = createRequire(root);
-  try {
-    return pathToFileURL(require2.resolve(entrypoint));
-  } catch {
-    return new URL(entrypoint, root);
-  }
-}
 function pickFontFaceProperty(property, { data, family }) {
   return data[property] ?? (family.provider === LOCAL_PROVIDER_NAME ? void 0 : family[property]);
 }
@@ -80,7 +70,6 @@ export {
   pickFontFaceProperty,
   renderFontSrc,
   renderFontWeight,
-  resolveEntrypoint,
   sortObjectByKey,
   unifontFontFaceDataToProperties,
   withoutQuotes