@remotion/google-fonts 4.0.277 → 4.0.279

package/dist/cjs/from-info.d.ts

@@ -0,0 +1,10 @@
+export declare const loadFontFromInfo: (meta: import("./base").FontInfo, style?: string, options?: {
+    weights?: string[];
+    subsets?: string[];
+    document?: Document;
+}) => {
+    fontFamily: import("./base").FontInfo["fontFamily"];
+    fonts: import("./base").FontInfo["fonts"];
+    unicodeRanges: import("./base").FontInfo["unicodeRanges"];
+    waitUntilDone: () => Promise<undefined>;
+};

package/dist/cjs/from-info.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFontFromInfo = void 0;
+const base_1 = require("./base");
+exports.loadFontFromInfo = base_1.loadFonts;

package/dist/esm/from-info.mjs

@@ -0,0 +1,76 @@
+// src/base.ts
+import { continueRender, delayRender } from "remotion";
+var loadedFonts = {};
+var loadFonts = (meta, style, options) => {
+  const promises = [];
+  const styles = style ? [style] : Object.keys(meta.fonts);
+  for (const style2 of styles) {
+    if (typeof FontFace === "undefined") {
+      continue;
+    }
+    if (!meta.fonts[style2]) {
+      throw new Error(`The font ${meta.fontFamily} does not have a style ${style2}`);
+    }
+    const weights = options?.weights ?? Object.keys(meta.fonts[style2]);
+    for (const weight of weights) {
+      if (!meta.fonts[style2][weight]) {
+        throw new Error(`The font ${meta.fontFamily} does not  have a weight ${weight} in style ${style2}`);
+      }
+      const subsets = options?.subsets ?? Object.keys(meta.fonts[style2][weight]);
+      for (const subset of subsets) {
+        let font = meta.fonts[style2]?.[weight]?.[subset];
+        if (!font) {
+          throw new Error(`weight: ${weight} subset: ${subset} is not available for '${meta.fontFamily}'`);
+        }
+        let fontKey = `${meta.fontFamily}-${style2}-${weight}-${subset}`;
+        const previousPromise = loadedFonts[fontKey];
+        if (previousPromise) {
+          promises.push(previousPromise);
+          continue;
+        }
+        const handle = delayRender(`Fetching ${meta.fontFamily} font ${JSON.stringify({
+          style: style2,
+          weight,
+          subset
+        })}`, { timeoutInMilliseconds: 60000 });
+        const fontFace = new FontFace(meta.fontFamily, `url(${font}) format('woff2')`, {
+          weight,
+          style: style2,
+          unicodeRange: meta.unicodeRanges[subset]
+        });
+        let attempts = 2;
+        const tryToLoad = () => {
+          const promise = fontFace.load().then(() => {
+            (options?.document ?? document).fonts.add(fontFace);
+            continueRender(handle);
+          }).catch((err) => {
+            loadedFonts[fontKey] = undefined;
+            if (attempts === 0) {
+              throw err;
+            } else {
+              attempts--;
+              tryToLoad();
+            }
+          });
+          loadedFonts[fontKey] = promise;
+          promises.push(promise);
+        };
+        tryToLoad();
+      }
+    }
+  }
+  return {
+    fontFamily: meta.fontFamily,
+    fonts: meta.fonts,
+    unicodeRanges: meta.unicodeRanges,
+    waitUntilDone: () => Promise.all(promises).then(() => {
+      return;
+    })
+  };
+};
+
+// src/from-info.ts
+var loadFontFromInfo = loadFonts;
+export {
+  loadFontFromInfo
+};