@unocss/preset-web-fonts 0.58.9 → 0.59.0

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@unocss/preset-web-fonts",
-  "version": "0.58.9",
+  "type": "module",
+  "version": "0.59.0",
   "description": "Web Fonts support for Uno CSS",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -24,12 +25,11 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     }
   },
-  "main": "dist/index.cjs",
+  "main": "dist/index.mjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "files": [
@@ -38,7 +38,7 @@
   ],
   "dependencies": {
     "ofetch": "^1.3.4",
-    "@unocss/core": "0.58.9"
+    "@unocss/core": "0.59.0"
   },
   "scripts": {
     "build": "unbuild",

package/dist/index.cjs

@@ -1,184 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const core = require('@unocss/core');
-
-const LAYER_IMPORTS = "imports";
-
-function createBunnyFontsProvider(name, host) {
-  return {
-    name,
-    getImportUrl(fonts) {
-      const fontFamilies = fonts.map((font) => {
-        const { name: name2, weights, italic } = font;
-        const formattedName = name2.toLowerCase().replace(/\s/g, "-");
-        if (!weights?.length)
-          return `${formattedName}${italic ? ":i" : ""}`;
-        let weightsAsString = weights.map((weight) => weight.toString());
-        const weightsHaveItalic = weightsAsString.some((weight) => weight.endsWith("i"));
-        if (!weightsHaveItalic && italic)
-          weightsAsString = weightsAsString.map((weight) => weight += "i");
-        return `${formattedName}:${weightsAsString.join(",")}`;
-      });
-      return `${host}/css?family=${fontFamilies.join("|")}&display=swap`;
-    }
-  };
-}
-const BunnyFontsProvider = createBunnyFontsProvider(
-  "bunny",
-  "https://fonts.bunny.net"
-);
-
-function createGoogleCompatibleProvider(name, host) {
-  return {
-    name,
-    getImportUrl(fonts) {
-      const sort = (weights) => {
-        const firstW = weights.map((w) => w[0]);
-        const lastW = weights.map((w) => w[1]);
-        return `${firstW.join(";")};${lastW.join(";")}`;
-      };
-      const strings = fonts.map((i) => {
-        let name2 = i.name.replace(/\s+/g, "+");
-        if (i.weights?.length) {
-          name2 += i.italic ? `:ital,wght@${sort(i.weights.map((w) => [`0,${w}`, `1,${w}`]))}` : `:wght@${i.weights.join(";")}`;
-        }
-        return `family=${name2}`;
-      }).join("&");
-      return `${host}/css2?${strings}&display=swap`;
-    }
-  };
-}
-const GoogleFontsProvider = createGoogleCompatibleProvider("google", "https://fonts.googleapis.com");
-
-const FontshareProvider = createFontshareProvider("fontshare", "https://api.fontshare.com");
-function createFontshareProvider(name, host) {
-  return {
-    name,
-    getImportUrl(fonts) {
-      const strings = fonts.map((f) => {
-        let name2 = f.name.replace(/\s+/g, "-").toLocaleLowerCase();
-        if (f.weights?.length)
-          name2 += `@${f.weights.flatMap((w) => f.italic ? Number(w) + 1 : w).sort().join()}`;
-        else
-          name2 += `@${f.italic ? 2 : 1}`;
-        return `f[]=${name2}`;
-      }).join("&");
-      return `${host}/v2/css?${strings}&display=swap`;
-    }
-  };
-}
-
-const NoneProvider = {
-  name: "none",
-  getPreflight() {
-    return "";
-  },
-  getFontName(font) {
-    return font.name;
-  }
-};
-
-const builtinProviders = {
-  google: GoogleFontsProvider,
-  bunny: BunnyFontsProvider,
-  fontshare: FontshareProvider,
-  none: NoneProvider
-};
-function resolveProvider(provider) {
-  if (typeof provider === "string")
-    return builtinProviders[provider];
-  return provider;
-}
-function normalizedFontMeta(meta, defaultProvider) {
-  if (typeof meta !== "string") {
-    meta.provider = resolveProvider(meta.provider || defaultProvider);
-    if (meta.weights)
-      meta.weights = [...new Set(meta.weights.sort((a, b) => a.toString().localeCompare(b.toString(), "en", { numeric: true })))];
-    return meta;
-  }
-  const [name, weights = ""] = meta.split(":");
-  return {
-    name,
-    weights: [...new Set(weights.split(/[,;]\s*/).filter(Boolean).sort((a, b) => a.localeCompare(b, "en", { numeric: true })))],
-    provider: resolveProvider(defaultProvider)
-  };
-}
-function createWebFontPreset(fetcher) {
-  return (options = {}) => {
-    const {
-      provider: defaultProvider = "google",
-      extendTheme = true,
-      inlineImports = true,
-      themeKey = "fontFamily",
-      customFetch = fetcher
-    } = options;
-    const fontObject = Object.fromEntries(
-      Object.entries(options.fonts || {}).map(([name, meta]) => [name, core.toArray(meta).map((m) => normalizedFontMeta(m, defaultProvider))])
-    );
-    const fonts = Object.values(fontObject).flatMap((i) => i);
-    const importCache = {};
-    async function importUrl(url) {
-      if (inlineImports) {
-        if (!importCache[url]) {
-          importCache[url] = customFetch(url).catch((e) => {
-            console.error("Failed to fetch web fonts");
-            console.error(e);
-            if (typeof process !== "undefined" && process.env.CI)
-              throw e;
-          });
-        }
-        return await importCache[url];
-      } else {
-        return `@import url('${url}');`;
-      }
-    }
-    const enabledProviders = new Set(fonts.map((i) => i.provider));
-    const preset = {
-      name: "@unocss/preset-web-fonts",
-      preflights: [
-        {
-          async getCSS() {
-            const preflights = [];
-            for (const provider of enabledProviders) {
-              const fontsForProvider = fonts.filter((i) => i.provider.name === provider.name);
-              if (provider.getImportUrl) {
-                const url = provider.getImportUrl(fontsForProvider);
-                if (url)
-                  preflights.push(await importUrl(url));
-              }
-              preflights.push(provider.getPreflight?.(fontsForProvider));
-            }
-            return preflights.filter(Boolean).join("\n");
-          },
-          layer: inlineImports ? void 0 : LAYER_IMPORTS
-        }
-      ]
-    };
-    if (extendTheme) {
-      preset.extendTheme = (theme) => {
-        if (!theme[themeKey])
-          theme[themeKey] = {};
-        const obj = Object.fromEntries(
-          Object.entries(fontObject).map(([name, fonts2]) => [name, fonts2.map((f) => f.provider.getFontName?.(f) ?? `"${f.name}"`)])
-        );
-        for (const key of Object.keys(obj)) {
-          if (typeof theme[themeKey][key] === "string")
-            theme[themeKey][key] = obj[key].map((i) => `${i},`).join("") + theme[themeKey][key];
-          else
-            theme[themeKey][key] = obj[key].join(",");
-        }
-      };
-    }
-    return preset;
-  };
-}
-
-const userAgentWoff2 = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36";
-const defaultFetch = async (url) => (await import('ofetch')).$fetch(url, { headers: { "User-Agent": userAgentWoff2 }, retry: 3 });
-const presetWebFonts = core.definePreset(createWebFontPreset(defaultFetch));
-
-exports.createGoogleProvider = createGoogleCompatibleProvider;
-exports.default = presetWebFonts;
-exports.normalizedFontMeta = normalizedFontMeta;

package/dist/index.d.cts

@@ -1,69 +0,0 @@
-import * as _unocss_core from '@unocss/core';
-
-type WebFontsProviders = 'google' | 'bunny' | 'fontshare' | 'none' | Provider;
-interface WebFontMeta {
-    name: string;
-    weights?: (string | number)[];
-    italic?: boolean;
-    /**
-     * Override the provider
-     * @default <matches root config>
-     */
-    provider?: WebFontsProviders;
-}
-interface ResolvedWebFontMeta extends Omit<WebFontMeta, 'provider'> {
-    provider: Provider;
-}
-interface WebFontsOptions {
-    /**
-     * Provider service of the web fonts
-     * @default 'google'
-     */
-    provider?: WebFontsProviders;
-    /**
-     * The fonts
-     */
-    fonts?: Record<string, WebFontMeta | string | (WebFontMeta | string)[]>;
-    /**
-     * Extend fonts to the theme object
-     * @default true
-     */
-    extendTheme?: boolean;
-    /**
-     * Key for the theme object
-     *
-     * @default 'fontFamily'
-     */
-    themeKey?: string;
-    /**
-     * Inline CSS @import()
-     *
-     * @default true
-     */
-    inlineImports?: boolean;
-    /**
-     * Custom fetch function
-     *
-     * @default undefined
-     */
-    customFetch?: (url: string) => Promise<any>;
-}
-interface Provider {
-    name: WebFontsProviders;
-    getPreflight?: (fonts: WebFontMeta[]) => string;
-    getImportUrl?: (fonts: WebFontMeta[]) => string | undefined;
-    getFontName?: (font: WebFontMeta) => string;
-}
-
-declare function normalizedFontMeta(meta: WebFontMeta | string, defaultProvider: WebFontsProviders): ResolvedWebFontMeta;
-
-declare function createGoogleCompatibleProvider(name: WebFontsProviders, host: string): Provider;
-
-/**
- * Preset for using web fonts by provide just the names.
- *
- * @see https://unocss.dev/presets/web-fonts
- */
-declare const presetWebFonts: _unocss_core.PresetFactory<any, WebFontsOptions>;
-
-export { type Provider, type ResolvedWebFontMeta, type WebFontMeta, type WebFontsOptions, type WebFontsProviders, createGoogleCompatibleProvider as createGoogleProvider, presetWebFonts as default, normalizedFontMeta };