astro 6.0.0-alpha.0 → 6.0.0-alpha.2

package/dist/assets/fonts/infra/dev-url-proxy-hash-resolver.js

@@ -0,0 +1,37 @@
+class DevUrlProxyHashResolver {
+  #hasher;
+  #contentResolver;
+  constructor({
+    hasher,
+    contentResolver
+  }) {
+    this.#hasher = hasher;
+    this.#contentResolver = contentResolver;
+  }
+  #formatWeight(weight) {
+    if (Array.isArray(weight)) {
+      return weight.join("-");
+    }
+    if (typeof weight === "number") {
+      return weight.toString();
+    }
+    return weight?.replace(/\s+/g, "-");
+  }
+  resolve({
+    cssVariable,
+    data,
+    originalUrl,
+    type
+  }) {
+    return [
+      cssVariable.slice(2),
+      this.#formatWeight(data.weight),
+      data.style,
+      data.subset,
+      `${this.#hasher.hashString(this.#contentResolver.resolve(originalUrl))}.${type}`
+    ].filter(Boolean).join("-");
+  }
+}
+export {
+  DevUrlProxyHashResolver
+};

package/dist/assets/fonts/infra/dev-url-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { UrlResolver } from '../definitions.js';
+export declare class DevUrlResolver implements UrlResolver {
+    #private;
+    constructor({ base, searchParams, }: {
+        base: string;
+        searchParams: URLSearchParams;
+    });
+    resolve(hash: string): string;
+    get cspResources(): Array<string>;
+}

package/dist/assets/fonts/infra/dev-url-resolver.js

@@ -0,0 +1,29 @@
+import { joinPaths, prependForwardSlash } from "../../../core/path.js";
+import { createPlaceholderURL, stringifyPlaceholderURL } from "../../utils/url.js";
+class DevUrlResolver {
+  #resolved = false;
+  #base;
+  #searchParams;
+  constructor({
+    base,
+    searchParams
+  }) {
+    this.#base = base;
+    this.#searchParams = searchParams;
+  }
+  resolve(hash) {
+    this.#resolved ||= true;
+    const urlPath = prependForwardSlash(joinPaths(this.#base, hash));
+    const url = createPlaceholderURL(urlPath);
+    this.#searchParams.forEach((value, key) => {
+      url.searchParams.set(key, value);
+    });
+    return stringifyPlaceholderURL(url);
+  }
+  get cspResources() {
+    return this.#resolved ? ["'self'"] : [];
+  }
+}
+export {
+  DevUrlResolver
+};

package/dist/assets/fonts/infra/font-type-extractor.d.ts

@@ -0,0 +1,5 @@
+import type { FontTypeExtractor } from '../definitions.js';
+import type { FontType } from '../types.js';
+export declare class RealFontTypeExtractor implements FontTypeExtractor {
+    extract(url: string): FontType;
+}

package/dist/assets/fonts/infra/font-type-extractor.js

@@ -0,0 +1,21 @@
+import { extname } from "node:path";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+import { isFontType } from "../utils.js";
+class RealFontTypeExtractor {
+  extract(url) {
+    const extension = extname(url).slice(1);
+    if (!isFontType(extension)) {
+      throw new AstroError(
+        {
+          ...AstroErrorData.CannotExtractFontType,
+          message: AstroErrorData.CannotExtractFontType.message(url)
+        },
+        { cause: `Unexpected extension, got "${extension}"` }
+      );
+    }
+    return extension;
+  }
+}
+export {
+  RealFontTypeExtractor
+};

package/dist/assets/fonts/infra/fontace-font-file-reader.d.ts

@@ -0,0 +1,11 @@
+import type { FontFileReader } from '../definitions.js';
+import type { Style } from '../types.js';
+export declare class FontaceFontFileReader implements FontFileReader {
+    extract({ family, url }: {
+        family: string;
+        url: string;
+    }): {
+        weight: string;
+        style: Style;
+    };
+}

package/dist/assets/fonts/infra/fontace-font-file-reader.js

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+import { fontace } from "fontace";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+class FontaceFontFileReader {
+  extract({ family, url }) {
+    try {
+      const data = fontace(readFileSync(url));
+      return {
+        weight: data.weight,
+        style: data.style
+      };
+    } catch (cause) {
+      throw new AstroError(
+        {
+          ...AstroErrorData.CannotDetermineWeightAndStyleFromFontFile,
+          message: AstroErrorData.CannotDetermineWeightAndStyleFromFontFile.message(family, url)
+        },
+        { cause }
+      );
+    }
+  }
+}
+export {
+  FontaceFontFileReader
+};

package/dist/assets/fonts/infra/levenshtein-string-matcher.d.ts

@@ -0,0 +1,5 @@
+import type { StringMatcher } from '../definitions.js';
+export declare class LevenshteinStringMatcher implements StringMatcher {
+    #private;
+    getClosestMatch(target: string, candidates: Array<string>): string;
+}

package/dist/assets/fonts/infra/levenshtein-string-matcher.js

@@ -0,0 +1,145 @@
+class LevenshteinStringMatcher {
+  #peq = new Uint32Array(65536);
+  #myers_32(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const lst = 1 << n - 1;
+    let pv = -1;
+    let mv = 0;
+    let sc = n;
+    let i = n;
+    while (i--) {
+      this.#peq[a.charCodeAt(i)] |= 1 << i;
+    }
+    for (i = 0; i < m; i++) {
+      let eq = this.#peq[b.charCodeAt(i)];
+      const xv = eq | mv;
+      eq |= (eq & pv) + pv ^ pv;
+      mv |= ~(eq | pv);
+      pv &= eq;
+      if (mv & lst) {
+        sc++;
+      }
+      if (pv & lst) {
+        sc--;
+      }
+      mv = mv << 1 | 1;
+      pv = pv << 1 | ~(xv | mv);
+      mv &= xv;
+    }
+    i = n;
+    while (i--) {
+      this.#peq[a.charCodeAt(i)] = 0;
+    }
+    return sc;
+  }
+  #myers_x(b, a) {
+    const n = a.length;
+    const m = b.length;
+    const mhc = [];
+    const phc = [];
+    const hsize = Math.ceil(n / 32);
+    const vsize = Math.ceil(m / 32);
+    for (let i = 0; i < hsize; i++) {
+      phc[i] = -1;
+      mhc[i] = 0;
+    }
+    let j = 0;
+    for (; j < vsize - 1; j++) {
+      let mv2 = 0;
+      let pv2 = -1;
+      const start2 = j * 32;
+      const vlen2 = Math.min(32, m) + start2;
+      for (let k = start2; k < vlen2; k++) {
+        this.#peq[b.charCodeAt(k)] |= 1 << k;
+      }
+      for (let i = 0; i < n; i++) {
+        const eq = this.#peq[a.charCodeAt(i)];
+        const pb = phc[i / 32 | 0] >>> i & 1;
+        const mb = mhc[i / 32 | 0] >>> i & 1;
+        const xv = eq | mv2;
+        const xh = ((eq | mb) & pv2) + pv2 ^ pv2 | eq | mb;
+        let ph = mv2 | ~(xh | pv2);
+        let mh = pv2 & xh;
+        if (ph >>> 31 ^ pb) {
+          phc[i / 32 | 0] ^= 1 << i;
+        }
+        if (mh >>> 31 ^ mb) {
+          mhc[i / 32 | 0] ^= 1 << i;
+        }
+        ph = ph << 1 | pb;
+        mh = mh << 1 | mb;
+        pv2 = mh | ~(xv | ph);
+        mv2 = ph & xv;
+      }
+      for (let k = start2; k < vlen2; k++) {
+        this.#peq[b.charCodeAt(k)] = 0;
+      }
+    }
+    let mv = 0;
+    let pv = -1;
+    const start = j * 32;
+    const vlen = Math.min(32, m - start) + start;
+    for (let k = start; k < vlen; k++) {
+      this.#peq[b.charCodeAt(k)] |= 1 << k;
+    }
+    let score = m;
+    for (let i = 0; i < n; i++) {
+      const eq = this.#peq[a.charCodeAt(i)];
+      const pb = phc[i / 32 | 0] >>> i & 1;
+      const mb = mhc[i / 32 | 0] >>> i & 1;
+      const xv = eq | mv;
+      const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+      let ph = mv | ~(xh | pv);
+      let mh = pv & xh;
+      score += ph >>> m - 1 & 1;
+      score -= mh >>> m - 1 & 1;
+      if (ph >>> 31 ^ pb) {
+        phc[i / 32 | 0] ^= 1 << i;
+      }
+      if (mh >>> 31 ^ mb) {
+        mhc[i / 32 | 0] ^= 1 << i;
+      }
+      ph = ph << 1 | pb;
+      mh = mh << 1 | mb;
+      pv = mh | ~(xv | ph);
+      mv = ph & xv;
+    }
+    for (let k = start; k < vlen; k++) {
+      this.#peq[b.charCodeAt(k)] = 0;
+    }
+    return score;
+  }
+  #distance(a, b) {
+    if (a.length < b.length) {
+      const tmp = b;
+      b = a;
+      a = tmp;
+    }
+    if (b.length === 0) {
+      return a.length;
+    }
+    if (a.length <= 32) {
+      return this.#myers_32(a, b);
+    }
+    return this.#myers_x(a, b);
+  }
+  #closest(str, arr) {
+    let min_distance = Infinity;
+    let min_index = 0;
+    for (let i = 0; i < arr.length; i++) {
+      const dist = this.#distance(str, arr[i]);
+      if (dist < min_distance) {
+        min_distance = dist;
+        min_index = i;
+      }
+    }
+    return arr[min_index];
+  }
+  getClosestMatch(target, candidates) {
+    return this.#closest(target, candidates);
+  }
+}
+export {
+  LevenshteinStringMatcher
+};

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

@@ -0,0 +1,4 @@
+import type { UrlProxyContentResolver } from '../definitions.js';
+export declare class LocalUrlProxyContentResolver implements UrlProxyContentResolver {
+    resolve(url: string): string;
+}

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

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+class LocalUrlProxyContentResolver {
+  resolve(url) {
+    try {
+      return url + readFileSync(url, "utf-8");
+    } catch (cause) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
+    }
+  }
+}
+export {
+  LocalUrlProxyContentResolver
+};

package/dist/assets/fonts/{implementations/css-renderer.d.ts → infra/minifiable-css-renderer.d.ts}

@@ -4,6 +4,11 @@ export declare function renderCssVariable(key: string, values: Array<string>, mi
 export declare function withFamily(family: string, properties: CssProperties): CssProperties;
 /** If the value contains spaces (which would be incorrectly interpreted), we wrap it in quotes. */
 export declare function handleValueWithSpaces(value: string): string;
-export declare function createMinifiableCssRenderer({ minify }: {
-    minify: boolean;
-}): CssRenderer;
+export declare class MinifiableCssRenderer implements CssRenderer {
+    #private;
+    constructor({ minify }: {
+        minify: boolean;
+    });
+    generateFontFace(family: string, properties: CssProperties): string;
+    generateCssVariable(key: string, values: Array<string>): string;
+}

package/dist/assets/fonts/{implementations/css-renderer.js → infra/minifiable-css-renderer.js}

@@ -23,18 +23,20 @@ function handleValueWithSpaces(value) {
   }
   return value;
 }
-function createMinifiableCssRenderer({ minify }) {
-  return {
-    generateFontFace(family, properties) {
-      return renderFontFace(withFamily(family, properties), minify);
-    },
-    generateCssVariable(key, values) {
-      return renderCssVariable(key, values, minify);
-    }
-  };
+class MinifiableCssRenderer {
+  #minify;
+  constructor({ minify }) {
+    this.#minify = minify;
+  }
+  generateFontFace(family, properties) {
+    return renderFontFace(withFamily(family, properties), this.#minify);
+  }
+  generateCssVariable(key, values) {
+    return renderCssVariable(key, values, this.#minify);
+  }
 }
 export {
-  createMinifiableCssRenderer,
+  MinifiableCssRenderer,
   handleValueWithSpaces,
   renderCssVariable,
   renderFontFace,

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

@@ -0,0 +1,10 @@
+import type { RemoteFontProviderModResolver, RemoteFontProviderResolver } from '../definitions.js';
+import type { AstroFontProvider, ResolvedFontProvider } from '../types.js';
+export declare class RealRemoteFontProviderResolver implements RemoteFontProviderResolver {
+    #private;
+    constructor({ root, modResolver, }: {
+        root: URL;
+        modResolver: RemoteFontProviderModResolver;
+    });
+    resolve({ entrypoint, config }: AstroFontProvider): Promise<ResolvedFontProvider>;
+}

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

@@ -0,0 +1,49 @@
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+import { resolveEntrypoint } from "../utils.js";
+class RealRemoteFontProviderResolver {
+  #root;
+  #modResolver;
+  constructor({
+    root,
+    modResolver
+  }) {
+    this.#root = root;
+    this.#modResolver = modResolver;
+  }
+  #validateMod({
+    mod,
+    entrypoint
+  }) {
+    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 new AstroError(
+        {
+          ...AstroErrorData.CannotLoadFontProvider,
+          message: AstroErrorData.CannotLoadFontProvider.message(entrypoint)
+        },
+        { cause }
+      );
+    }
+  }
+  async resolve({ entrypoint, config }) {
+    const id = resolveEntrypoint(this.#root, entrypoint.toString()).href;
+    const mod = await this.#modResolver.resolve(id);
+    const { provider } = this.#validateMod({
+      mod,
+      entrypoint: id
+    });
+    return { config, provider };
+  }
+}
+export {
+  RealRemoteFontProviderResolver
+};

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

@@ -0,0 +1,4 @@
+import type { UrlProxyContentResolver } from '../definitions.js';
+export declare class RemoteUrlProxyContentResolver implements UrlProxyContentResolver {
+    resolve(url: string): string;
+}

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

@@ -0,0 +1,9 @@
+class RemoteUrlProxyContentResolver {
+  // Passthrough, the remote provider URL is enough
+  resolve(url) {
+    return url;
+  }
+}
+export {
+  RemoteUrlProxyContentResolver
+};

package/dist/assets/fonts/infra/require-local-provider-url-resolver.d.ts

@@ -0,0 +1,9 @@
+import type { LocalProviderUrlResolver } from '../definitions.js';
+export declare class RequireLocalProviderUrlResolver implements LocalProviderUrlResolver {
+    #private;
+    constructor({ root, intercept, }: {
+        root: URL;
+        intercept?: ((path: string) => void) | undefined;
+    });
+    resolve(input: string): string;
+}

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

@@ -0,0 +1,22 @@
+import { fileURLToPath } from "node:url";
+import { resolveEntrypoint } from "../utils.js";
+class RequireLocalProviderUrlResolver {
+  #root;
+  // TODO: remove when stabilizing
+  #intercept;
+  constructor({
+    root,
+    intercept
+  }) {
+    this.#root = root;
+    this.#intercept = intercept;
+  }
+  resolve(input) {
+    const path = fileURLToPath(resolveEntrypoint(this.#root, input));
+    this.#intercept?.(path);
+    return path;
+  }
+}
+export {
+  RequireLocalProviderUrlResolver
+};

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

@@ -0,0 +1,6 @@
+import type { SystemFallbacksProvider } from '../definitions.js';
+import type { FontFaceMetrics, GenericFallbackName } from '../types.js';
+export declare class RealSystemFallbacksProvider implements SystemFallbacksProvider {
+    getLocalFonts(fallback: GenericFallbackName): Array<string> | null;
+    getMetricsForLocalFont(family: string): FontFaceMetrics;
+}

package/dist/assets/fonts/{implementations → infra}/system-fallbacks-provider.js

@@ -58,17 +58,14 @@ const DEFAULT_FALLBACKS = {
   "ui-sans-serif": ["Arial"],
   "ui-monospace": ["Courier New"]
 };
-function createSystemFallbacksProvider() {
-  return {
-    getLocalFonts(fallback) {
-      return DEFAULT_FALLBACKS[fallback] ?? null;
-    },
-    getMetricsForLocalFont(family) {
-      return SYSTEM_METRICS[family];
-    }
-  };
+class RealSystemFallbacksProvider {
+  getLocalFonts(fallback) {
+    return DEFAULT_FALLBACKS[fallback] ?? null;
+  }
+  getMetricsForLocalFont(family) {
+    return SYSTEM_METRICS[family];
+  }
 }
 export {
-  DEFAULT_FALLBACKS,
-  createSystemFallbacksProvider
+  RealSystemFallbacksProvider
 };

package/dist/assets/fonts/infra/unstorage-fs-storage.d.ts

@@ -0,0 +1,11 @@
+import type { Storage } from '../definitions.js';
+export declare class UnstorageFsStorage implements Storage {
+    #private;
+    constructor({ base }: {
+        base: URL;
+    });
+    getItem(key: string): Promise<any | null>;
+    getItemRaw(key: string): Promise<Buffer | null>;
+    setItem(key: string, value: any): Promise<void>;
+    setItemRaw(key: string, value: any): Promise<void>;
+}

package/dist/assets/fonts/infra/unstorage-fs-storage.js

@@ -0,0 +1,26 @@
+import { fileURLToPath } from "node:url";
+import * as unstorage from "unstorage";
+import fsLiteDriver from "unstorage/drivers/fs-lite";
+class UnstorageFsStorage {
+  #unstorage;
+  constructor({ base }) {
+    this.#unstorage = unstorage.createStorage({
+      driver: fsLiteDriver({ base: fileURLToPath(base) })
+    });
+  }
+  async getItem(key) {
+    return await this.#unstorage.getItem(key);
+  }
+  async getItemRaw(key) {
+    return await this.#unstorage.getItemRaw(key);
+  }
+  async setItem(key, value) {
+    return await this.#unstorage.setItem(key, value);
+  }
+  async setItemRaw(key, value) {
+    return await this.#unstorage.setItemRaw(key, value);
+  }
+}
+export {
+  UnstorageFsStorage
+};

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

@@ -0,0 +1,16 @@
+import type { DataCollector, ProxyData, UrlProxy, UrlProxyHashResolver, UrlResolver } from '../definitions.js';
+import type { FontFileData, FontType } from '../types.js';
+export declare class RealUrlProxy implements UrlProxy {
+    #private;
+    constructor({ hashResolver, dataCollector, urlResolver, cssVariable, }: {
+        hashResolver: UrlProxyHashResolver;
+        dataCollector: DataCollector;
+        urlResolver: UrlResolver;
+        cssVariable: string;
+    });
+    proxy({ url: originalUrl, type, data, collectPreload, init, }: Pick<FontFileData, 'url' | 'init'> & {
+        type: FontType;
+        collectPreload: boolean;
+        data: ProxyData;
+    }): string;
+}

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

@@ -0,0 +1,50 @@
+import { renderFontWeight } from "../utils.js";
+class RealUrlProxy {
+  #hashResolver;
+  #dataCollector;
+  #urlResolver;
+  #cssVariable;
+  constructor({
+    hashResolver,
+    dataCollector,
+    urlResolver,
+    cssVariable
+  }) {
+    this.#hashResolver = hashResolver;
+    this.#dataCollector = dataCollector;
+    this.#urlResolver = urlResolver;
+    this.#cssVariable = cssVariable;
+  }
+  proxy({
+    url: originalUrl,
+    type,
+    data,
+    collectPreload,
+    init
+  }) {
+    const hash = this.#hashResolver.resolve({
+      cssVariable: this.#cssVariable,
+      data,
+      originalUrl,
+      type
+    });
+    const url = this.#urlResolver.resolve(hash);
+    this.#dataCollector.collect({
+      url: originalUrl,
+      hash,
+      preload: collectPreload ? {
+        url,
+        type,
+        weight: renderFontWeight(data.weight),
+        style: data.style,
+        subset: data.subset
+      } : null,
+      data,
+      init
+    });
+    return url;
+  }
+}
+export {
+  RealUrlProxy
+};

package/dist/assets/fonts/infra/xxhash-hasher.d.ts

@@ -0,0 +1,7 @@
+import type { Hasher } from '../definitions.js';
+export declare class XxhashHasher implements Hasher {
+    hashString: (input: string) => string;
+    private constructor();
+    static create(): Promise<XxhashHasher>;
+    hashObject(input: Record<string, any>): string;
+}

package/dist/assets/fonts/infra/xxhash-hasher.js

@@ -0,0 +1,18 @@
+import xxhash from "xxhash-wasm";
+import { sortObjectByKey } from "../utils.js";
+class XxhashHasher {
+  hashString;
+  constructor(hashString) {
+    this.hashString = hashString;
+  }
+  static async create() {
+    const { h64ToString } = await xxhash();
+    return new XxhashHasher(h64ToString);
+  }
+  hashObject(input) {
+    return this.hashString(JSON.stringify(sortObjectByKey(input)));
+  }
+}
+export {
+  XxhashHasher
+};

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

@@ -1,6 +1,5 @@
-import type { Storage } from 'unstorage';
 import type { Logger } from '../../core/logger/core.js';
-import type { CssRenderer, FontFileReader, FontMetricsResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.js';
+import type { CssRenderer, FontFileReader, FontMetricsResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, Storage, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.js';
 import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFileDataMap, InternalConsumableMap } from './types.js';
 /**
  * Manages how fonts are resolved: