astro 5.7.5 → 5.7.7

package/dist/assets/fonts/implementations/local-provider-url-resolver.js

@@ -0,0 +1,17 @@
+import { fileURLToPath } from "node:url";
+import { resolveEntrypoint } from "../utils.js";
+function createRequireLocalProviderUrlResolver({
+  root,
+  intercept
+}) {
+  return {
+    resolve(input) {
+      const path = fileURLToPath(resolveEntrypoint(root, input));
+      intercept?.(path);
+      return path;
+    }
+  };
+}
+export {
+  createRequireLocalProviderUrlResolver
+};

package/dist/assets/fonts/implementations/remote-font-provider-mod-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { ViteDevServer } from 'vite';
+import type { RemoteFontProviderModResolver } from '../definitions.js';
+export declare function createBuildRemoteFontProviderModResolver(): RemoteFontProviderModResolver;
+export declare function createDevServerRemoteFontProviderModResolver({ server, }: {
+    server: ViteDevServer;
+}): RemoteFontProviderModResolver;

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

@@ -0,0 +1,20 @@
+function createBuildRemoteFontProviderModResolver() {
+  return {
+    resolve(id) {
+      return import(id);
+    }
+  };
+}
+function createDevServerRemoteFontProviderModResolver({
+  server
+}) {
+  return {
+    resolve(id) {
+      return server.ssrLoadModule(id);
+    }
+  };
+}
+export {
+  createBuildRemoteFontProviderModResolver,
+  createDevServerRemoteFontProviderModResolver
+};

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

@@ -0,0 +1,6 @@
+import type { ErrorHandler, RemoteFontProviderModResolver, RemoteFontProviderResolver } from '../definitions.js';
+export declare function createRemoteFontProviderResolver({ root, modResolver, errorHandler, }: {
+    root: URL;
+    modResolver: RemoteFontProviderModResolver;
+    errorHandler: ErrorHandler;
+}): RemoteFontProviderResolver;

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;
+}>;