astro 5.7.6 → 5.7.8

package/dist/assets/fonts/implementations/remote-font-provider-resolver.js

@@ -0,0 +1,47 @@
+import { resolveEntrypoint } from "../utils.js";
+function validateMod({
+  mod,
+  entrypoint,
+  errorHandler
+}) {
+  try {
+    if (typeof mod !== "object" || mod === null) {
+      throw new Error(`Expected an object for the module, but received ${typeof mod}.`);
+    }
+    if (typeof mod.provider !== "function") {
+      throw new Error(`Invalid provider export in module, expected a function.`);
+    }
+    return {
+      provider: mod.provider
+    };
+  } catch (cause) {
+    throw errorHandler.handle({
+      type: "cannot-load-font-provider",
+      data: {
+        entrypoint
+      },
+      cause
+    });
+  }
+}
+function createRemoteFontProviderResolver({
+  root,
+  modResolver,
+  errorHandler
+}) {
+  return {
+    async resolve({ entrypoint, config }) {
+      const id = resolveEntrypoint(root, entrypoint.toString()).href;
+      const mod = await modResolver.resolve(id);
+      const { provider } = validateMod({
+        mod,
+        entrypoint: id,
+        errorHandler
+      });
+      return { config, provider };
+    }
+  };
+}
+export {
+  createRemoteFontProviderResolver
+};

package/dist/assets/fonts/implementations/storage.d.ts

@@ -0,0 +1,4 @@
+import { type Storage } from 'unstorage';
+export declare function createFsStorage({ base }: {
+    base: URL;
+}): Storage;

package/dist/assets/fonts/implementations/storage.js

@@ -0,0 +1,14 @@
+import { fileURLToPath } from "node:url";
+import { createStorage } from "unstorage";
+import fsLiteDriver from "unstorage/drivers/fs-lite";
+function createFsStorage({ base }) {
+  return createStorage({
+    // Types are weirly exported
+    driver: fsLiteDriver({
+      base: fileURLToPath(base)
+    })
+  });
+}
+export {
+  createFsStorage
+};

package/dist/assets/fonts/implementations/system-fallbacks-provider.d.ts

@@ -0,0 +1,11 @@
+import type { SystemFallbacksProvider } from '../definitions.js';
+export declare const DEFAULT_FALLBACKS: {
+    serif: "Times New Roman"[];
+    'sans-serif': "Arial"[];
+    monospace: "Courier New"[];
+    'system-ui': ("Arial" | "BlinkMacSystemFont" | "Segoe UI" | "Roboto" | "Helvetica Neue")[];
+    'ui-serif': "Times New Roman"[];
+    'ui-sans-serif': "Arial"[];
+    'ui-monospace': "Courier New"[];
+};
+export declare function createSystemFallbacksProvider(): SystemFallbacksProvider;

package/dist/assets/fonts/implementations/system-fallbacks-provider.js

@@ -0,0 +1,74 @@
+const SYSTEM_METRICS = {
+  "Times New Roman": {
+    ascent: 1825,
+    descent: -443,
+    lineGap: 87,
+    unitsPerEm: 2048,
+    xWidthAvg: 832
+  },
+  Arial: {
+    ascent: 1854,
+    descent: -434,
+    lineGap: 67,
+    unitsPerEm: 2048,
+    xWidthAvg: 913
+  },
+  "Courier New": {
+    ascent: 1705,
+    descent: -615,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 1229
+  },
+  BlinkMacSystemFont: {
+    ascent: 1980,
+    descent: -432,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 853
+  },
+  "Segoe UI": {
+    ascent: 2210,
+    descent: -514,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 908
+  },
+  Roboto: {
+    ascent: 1900,
+    descent: -500,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 911
+  },
+  "Helvetica Neue": {
+    ascent: 952,
+    descent: -213,
+    lineGap: 28,
+    unitsPerEm: 1e3,
+    xWidthAvg: 450
+  }
+};
+const DEFAULT_FALLBACKS = {
+  serif: ["Times New Roman"],
+  "sans-serif": ["Arial"],
+  monospace: ["Courier New"],
+  "system-ui": ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial"],
+  "ui-serif": ["Times New Roman"],
+  "ui-sans-serif": ["Arial"],
+  "ui-monospace": ["Courier New"]
+};
+function createSystemFallbacksProvider() {
+  return {
+    getLocalFonts(fallback) {
+      return DEFAULT_FALLBACKS[fallback] ?? null;
+    },
+    getMetricsForLocalFont(family) {
+      return SYSTEM_METRICS[family];
+    }
+  };
+}
+export {
+  DEFAULT_FALLBACKS,
+  createSystemFallbacksProvider
+};

package/dist/assets/fonts/implementations/url-proxy-content-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { ErrorHandler, UrlProxyContentResolver } from '../definitions.js';
+export declare function createLocalUrlProxyContentResolver({ errorHandler, }: {
+    errorHandler: ErrorHandler;
+}): UrlProxyContentResolver;
+export declare function createRemoteUrlProxyContentResolver(): UrlProxyContentResolver;

package/dist/assets/fonts/implementations/url-proxy-content-resolver.js

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+function createLocalUrlProxyContentResolver({
+  errorHandler
+}) {
+  return {
+    resolve(url) {
+      try {
+        return url + readFileSync(url, "utf-8");
+      } catch (cause) {
+        throw errorHandler.handle({
+          type: "unknown-fs-error",
+          data: {},
+          cause
+        });
+      }
+    }
+  };
+}
+function createRemoteUrlProxyContentResolver() {
+  return {
+    // Passthrough, the remote provider URL is enough
+    resolve: (url) => url
+  };
+}
+export {
+  createLocalUrlProxyContentResolver,
+  createRemoteUrlProxyContentResolver
+};

package/dist/assets/fonts/implementations/url-proxy.d.ts

@@ -0,0 +1,8 @@
+import type { DataCollector, FontTypeExtractor, Hasher, UrlProxy, UrlProxyContentResolver } from '../definitions.js';
+export declare function createUrlProxy({ base, contentResolver, hasher, dataCollector, fontTypeExtractor, }: {
+    base: string;
+    contentResolver: UrlProxyContentResolver;
+    hasher: Hasher;
+    dataCollector: DataCollector;
+    fontTypeExtractor: FontTypeExtractor;
+}): UrlProxy;

package/dist/assets/fonts/implementations/url-proxy.js

@@ -0,0 +1,26 @@
+function createUrlProxy({
+  base,
+  contentResolver,
+  hasher,
+  dataCollector,
+  fontTypeExtractor
+}) {
+  return {
+    proxy({ url: originalUrl, data, collectPreload, init }) {
+      const type = fontTypeExtractor.extract(originalUrl);
+      const hash = `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`;
+      const url = base + hash;
+      dataCollector.collect({
+        url: originalUrl,
+        hash,
+        preload: collectPreload ? { url, type } : null,
+        data,
+        init
+      });
+      return url;
+    }
+  };
+}
+export {
+  createUrlProxy
+};

package/dist/assets/fonts/logic/extract-unifont-providers.d.ts

@@ -0,0 +1,10 @@
+import type * as unifont from 'unifont';
+import type { Hasher } from '../definitions.js';
+import type { ResolvedFontFamily } from '../types.js';
+export declare function extractUnifontProviders({ families, hasher, }: {
+    families: Array<ResolvedFontFamily>;
+    hasher: Hasher;
+}): {
+    families: Array<ResolvedFontFamily>;
+    providers: Array<unifont.Provider>;
+};

package/dist/assets/fonts/logic/extract-unifont-providers.js

@@ -0,0 +1,28 @@
+import { LOCAL_PROVIDER_NAME } from "../constants.js";
+function extractUnifontProviders({
+  families,
+  hasher
+}) {
+  const hashes = /* @__PURE__ */ new Set();
+  const providers = [];
+  for (const { provider } of families) {
+    if (provider === LOCAL_PROVIDER_NAME) {
+      continue;
+    }
+    const unifontProvider = provider.provider(provider.config);
+    const hash = hasher.hashObject({
+      name: unifontProvider._name,
+      ...provider.config
+    });
+    unifontProvider._name += `-${hash}`;
+    provider.name = unifontProvider._name;
+    if (!hashes.has(hash)) {
+      hashes.add(hash);
+      providers.push(unifontProvider);
+    }
+  }
+  return { families, providers };
+}
+export {
+  extractUnifontProviders
+};

package/dist/assets/fonts/logic/normalize-remote-font-faces.d.ts

@@ -0,0 +1,6 @@
+import type * as unifont from 'unifont';
+import type { UrlProxy } from '../definitions.js';
+export declare function normalizeRemoteFontFaces({ fonts, urlProxy, }: {
+    fonts: Array<unifont.FontFaceData>;
+    urlProxy: UrlProxy;
+}): Array<unifont.FontFaceData>;

package/dist/assets/fonts/logic/normalize-remote-font-faces.js

@@ -0,0 +1,36 @@
+function normalizeRemoteFontFaces({
+  fonts,
+  urlProxy
+}) {
+  return fonts.filter((font) => typeof font.meta?.priority === "number" ? font.meta.priority === 0 : true).map((font) => {
+    let index = 0;
+    return {
+      ...font,
+      src: font.src.map((source) => {
+        if ("name" in source) {
+          return source;
+        }
+        const proxied = {
+          ...source,
+          originalURL: source.url,
+          url: urlProxy.proxy({
+            url: source.url,
+            // We only collect the first URL to avoid preloading fallback sources (eg. we only
+            // preload woff2 if woff is available)
+            collectPreload: index === 0,
+            data: {
+              weight: font.weight,
+              style: font.style
+            },
+            init: font.meta?.init ?? null
+          })
+        };
+        index++;
+        return proxied;
+      })
+    };
+  });
+}
+export {
+  normalizeRemoteFontFaces
+};

package/dist/assets/fonts/logic/optimize-fallbacks.d.ts

@@ -0,0 +1,17 @@
+import type * as unifont from 'unifont';
+import type { FontMetricsResolver, SystemFallbacksProvider } from '../definitions.js';
+import type { FontFileData, ResolvedFontFamily } from '../types.js';
+export interface CollectedFontForMetrics extends FontFileData {
+    data: Partial<unifont.FontFaceData>;
+}
+export declare function optimizeFallbacks({ family, fallbacks: _fallbacks, collectedFonts, enabled, systemFallbacksProvider, fontMetricsResolver, }: {
+    family: Pick<ResolvedFontFamily, 'name' | 'nameWithHash'>;
+    fallbacks: Array<string>;
+    collectedFonts: Array<CollectedFontForMetrics>;
+    enabled: boolean;
+    systemFallbacksProvider: SystemFallbacksProvider;
+    fontMetricsResolver: FontMetricsResolver;
+}): Promise<null | {
+    css: string;
+    fallbacks: Array<string>;
+}>;

package/dist/assets/fonts/logic/optimize-fallbacks.js

@@ -0,0 +1,47 @@
+import { isGenericFontFamily, unifontFontFaceDataToProperties } from "../utils.js";
+async function optimizeFallbacks({
+  family,
+  fallbacks: _fallbacks,
+  collectedFonts,
+  enabled,
+  systemFallbacksProvider,
+  fontMetricsResolver
+}) {
+  let fallbacks = [..._fallbacks];
+  if (fallbacks.length === 0 || !enabled || collectedFonts.length === 0) {
+    return null;
+  }
+  const lastFallback = fallbacks[fallbacks.length - 1];
+  if (!isGenericFontFamily(lastFallback)) {
+    return null;
+  }
+  const localFonts = systemFallbacksProvider.getLocalFonts(lastFallback);
+  if (!localFonts || localFonts.length === 0) {
+    return null;
+  }
+  if (localFonts.includes(family.name)) {
+    return null;
+  }
+  const localFontsMappings = localFonts.map((font) => ({
+    font,
+    // We must't wrap in quote because that's handled by the CSS renderer
+    name: `${family.nameWithHash} fallback: ${font}`
+  }));
+  fallbacks = [...localFontsMappings.map((m) => m.name), ...fallbacks];
+  let css = "";
+  for (const { font, name } of localFontsMappings) {
+    for (const collected of collectedFonts) {
+      css += fontMetricsResolver.generateFontFace({
+        metrics: await fontMetricsResolver.getMetrics(family.name, collected),
+        fallbackMetrics: systemFallbacksProvider.getMetricsForLocalFont(font),
+        font,
+        name,
+        properties: unifontFontFaceDataToProperties(collected.data)
+      });
+    }
+  }
+  return { css, fallbacks };
+}
+export {
+  optimizeFallbacks
+};

package/dist/assets/fonts/logic/resolve-families.d.ts

@@ -0,0 +1,17 @@
+import type { Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver } from '../definitions.js';
+import type { FontFamily, ResolvedFontFamily } from '../types.js';
+/**
+ * Dedupes properties if applicable and resolves entrypoints.
+ */
+export declare function resolveFamily({ family, hasher, remoteFontProviderResolver, localProviderUrlResolver, }: {
+    family: FontFamily;
+    hasher: Hasher;
+    remoteFontProviderResolver: RemoteFontProviderResolver;
+    localProviderUrlResolver: LocalProviderUrlResolver;
+}): Promise<ResolvedFontFamily>;
+/**
+ * A function for convenience. The actual logic lives in resolveFamily
+ */
+export declare function resolveFamilies({ families, ...dependencies }: {
+    families: Array<FontFamily>;
+} & Omit<Parameters<typeof resolveFamily>[0], 'family'>): Promise<Array<ResolvedFontFamily>>;

package/dist/assets/fonts/logic/resolve-families.js

@@ -0,0 +1,67 @@
+import { LOCAL_PROVIDER_NAME } from "../constants.js";
+import { dedupe, withoutQuotes } from "../utils.js";
+function resolveVariants({
+  variants,
+  localProviderUrlResolver
+}) {
+  return variants.map((variant) => ({
+    ...variant,
+    weight: variant.weight.toString(),
+    src: variant.src.map((value) => {
+      const isValue = typeof value === "string" || value instanceof URL;
+      const url = (isValue ? value : value.url).toString();
+      const tech = isValue ? void 0 : value.tech;
+      return {
+        url: localProviderUrlResolver.resolve(url),
+        tech
+      };
+    })
+  }));
+}
+async function resolveFamily({
+  family,
+  hasher,
+  remoteFontProviderResolver,
+  localProviderUrlResolver
+}) {
+  const name = withoutQuotes(family.name);
+  const nameWithHash = `${name}-${hasher.hashObject(family)}`;
+  if (family.provider === LOCAL_PROVIDER_NAME) {
+    return {
+      ...family,
+      name,
+      nameWithHash,
+      variants: resolveVariants({ variants: family.variants, localProviderUrlResolver }),
+      fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0
+    };
+  }
+  return {
+    ...family,
+    name,
+    nameWithHash,
+    weights: family.weights ? dedupe(family.weights.map((weight) => weight.toString())) : void 0,
+    styles: family.styles ? dedupe(family.styles) : void 0,
+    subsets: family.subsets ? dedupe(family.subsets) : void 0,
+    fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0,
+    unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0,
+    // This will be Astro specific eventually
+    provider: await remoteFontProviderResolver.resolve(family.provider)
+  };
+}
+async function resolveFamilies({
+  families,
+  ...dependencies
+}) {
+  return await Promise.all(
+    families.map(
+      (family) => resolveFamily({
+        family,
+        ...dependencies
+      })
+    )
+  );
+}
+export {
+  resolveFamilies,
+  resolveFamily
+};

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

@@ -0,0 +1,37 @@
+import type { Storage } from 'unstorage';
+import type { CssRenderer, FontMetricsResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, SystemFallbacksProvider, UrlProxy } from './definitions.js';
+import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFileDataMap } from './types.js';
+/**
+ * Manages how fonts are resolved:
+ *
+ * - families are resolved
+ * - unifont providers are extracted from families
+ * - unifont is initialized
+ *
+ * For each family:
+ * - We create a URL proxy
+ * - We resolve the font and normalize the result
+ *
+ * For each resolved font:
+ * - We generate the CSS font face
+ * - We generate optimized fallbacks if applicable
+ * - We generate CSS variables
+ *
+ * Once that's done, the collected data is returned
+ */
+export declare function orchestrate({ families, hasher, remoteFontProviderResolver, localProviderUrlResolver, storage, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, createUrlProxy, defaults, }: {
+    families: Array<FontFamily>;
+    hasher: Hasher;
+    remoteFontProviderResolver: RemoteFontProviderResolver;
+    localProviderUrlResolver: LocalProviderUrlResolver;
+    storage: Storage;
+    cssRenderer: CssRenderer;
+    systemFallbacksProvider: SystemFallbacksProvider;
+    fontMetricsResolver: FontMetricsResolver;
+    fontTypeExtractor: FontTypeExtractor;
+    createUrlProxy: (params: CreateUrlProxyParams) => UrlProxy;
+    defaults: Defaults;
+}): Promise<{
+    fontFileDataMap: FontFileDataMap;
+    consumableMap: ConsumableMap;
+}>;

package/dist/assets/fonts/orchestrate.js

@@ -0,0 +1,125 @@
+import * as unifont from "unifont";
+import { LOCAL_PROVIDER_NAME } from "./constants.js";
+import { extractUnifontProviders } from "./logic/extract-unifont-providers.js";
+import { normalizeRemoteFontFaces } from "./logic/normalize-remote-font-faces.js";
+import { optimizeFallbacks } from "./logic/optimize-fallbacks.js";
+import { resolveFamilies } from "./logic/resolve-families.js";
+import { resolveLocalFont } from "./providers/local.js";
+import { pickFontFaceProperty, unifontFontFaceDataToProperties } from "./utils.js";
+async function orchestrate({
+  families,
+  hasher,
+  remoteFontProviderResolver,
+  localProviderUrlResolver,
+  storage,
+  cssRenderer,
+  systemFallbacksProvider,
+  fontMetricsResolver,
+  fontTypeExtractor,
+  createUrlProxy,
+  defaults
+}) {
+  let resolvedFamilies = await resolveFamilies({
+    families,
+    hasher,
+    remoteFontProviderResolver,
+    localProviderUrlResolver
+  });
+  const extractedUnifontProvidersResult = extractUnifontProviders({
+    families: resolvedFamilies,
+    hasher
+  });
+  resolvedFamilies = extractedUnifontProvidersResult.families;
+  const unifontProviders = extractedUnifontProvidersResult.providers;
+  const { resolveFont } = await unifont.createUnifont(unifontProviders, {
+    storage
+  });
+  const fontFileDataMap = /* @__PURE__ */ new Map();
+  const consumableMap = /* @__PURE__ */ new Map();
+  for (const family of resolvedFamilies) {
+    const preloadData = [];
+    let css = "";
+    const collectedFonts = [];
+    const fallbacks = family.fallbacks ?? defaults.fallbacks ?? [];
+    const urlProxy = createUrlProxy({
+      local: family.provider === LOCAL_PROVIDER_NAME,
+      hasUrl: (hash) => fontFileDataMap.has(hash),
+      saveUrl: ({ hash, url, init }) => {
+        fontFileDataMap.set(hash, { url, init });
+      },
+      savePreload: (preload) => {
+        preloadData.push(preload);
+      },
+      saveFontData: (collected) => {
+        if (fallbacks && 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.
+        !collectedFonts.some((f) => JSON.stringify(f.data) === JSON.stringify(collected.data))) {
+          collectedFonts.push(collected);
+        }
+      }
+    });
+    let fonts;
+    if (family.provider === LOCAL_PROVIDER_NAME) {
+      const result = resolveLocalFont({
+        family,
+        urlProxy,
+        fontTypeExtractor
+      });
+      fonts = result.fonts;
+    } else {
+      const result = await resolveFont(
+        family.name,
+        // 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,
+          fallbacks: family.fallbacks ?? defaults.fallbacks
+        },
+        // 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).
+        [family.provider.name]
+      );
+      fonts = normalizeRemoteFontFaces({ fonts: result.fonts, urlProxy });
+    }
+    for (const data of fonts) {
+      css += cssRenderer.generateFontFace(
+        family.nameWithHash,
+        unifontFontFaceDataToProperties({
+          src: data.src,
+          weight: data.weight,
+          style: data.style,
+          // User settings override the generated font settings. We use a helper function
+          // because local and remote providers store this data in different places.
+          display: pickFontFaceProperty("display", { data, family }),
+          unicodeRange: pickFontFaceProperty("unicodeRange", { data, family }),
+          stretch: pickFontFaceProperty("stretch", { data, family }),
+          featureSettings: pickFontFaceProperty("featureSettings", { data, family }),
+          variationSettings: pickFontFaceProperty("variationSettings", { data, family })
+        })
+      );
+    }
+    const cssVarValues = [family.nameWithHash];
+    const optimizeFallbacksResult = await optimizeFallbacks({
+      family,
+      fallbacks,
+      collectedFonts,
+      enabled: family.optimizedFallbacks ?? defaults.optimizedFallbacks ?? false,
+      systemFallbacksProvider,
+      fontMetricsResolver
+    });
+    if (optimizeFallbacksResult) {
+      css += optimizeFallbacksResult.css;
+      cssVarValues.push(...optimizeFallbacksResult.fallbacks);
+    } else {
+      cssVarValues.push(...fallbacks);
+    }
+    css += cssRenderer.generateCssVariable(family.cssVariable, cssVarValues);
+    consumableMap.set(family.cssVariable, { preloadData, css });
+  }
+  return { fontFileDataMap, consumableMap };
+}
+export {
+  orchestrate
+};

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

@@ -1,13 +1,12 @@
 import type * as unifont from 'unifont';
+import type { FontTypeExtractor, UrlProxy } from '../definitions.js';
 import type { ResolvedLocalFontFamily } from '../types.js';
-type InitializedProvider = NonNullable<Awaited<ReturnType<unifont.Provider>>>;
-type ResolveFontResult = NonNullable<Awaited<ReturnType<InitializedProvider['resolveFont']>>>;
 interface Options {
     family: ResolvedLocalFontFamily;
-    proxyURL: (params: {
-        value: string;
-        data: Partial<unifont.FontFaceData>;
-    }) => string;
+    urlProxy: UrlProxy;
+    fontTypeExtractor: FontTypeExtractor;
 }
-export declare function resolveLocalFont({ family, proxyURL }: Options): ResolveFontResult;
+export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor }: Options): {
+    fonts: Array<unifont.FontFaceData>;
+};
 export {};