@cf-wasm/og/dist/cjs/core/render.js

Generate Open Graph Images dynamically from HTML/CSS without a browser.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/core/render.ts
var render_exports = {};
__export(render_exports, {
  RENDER_DEFAULT_OPTIONS: () => RENDER_DEFAULT_OPTIONS,
  render: () => render
});
module.exports = __toCommonJS(render_exports);
var import_asset = require("./asset.js");
var import_font = require("./font.js");
var import_modules = require("./modules.js");
var RENDER_DEFAULT_OPTIONS = {
  width: 1200,
  height: 630,
  debug: false,
  fonts: []
};
var render = (element, options = {}) => {
  const promises = {};
  const renderOptions = {
    ...RENDER_DEFAULT_OPTIONS,
    ...options
  };
  const loadAdditionalAsset = async (languageCode, segment) => {
    const next = () => (0, import_asset.loadDynamicAsset)(languageCode, segment, renderOptions?.emoji);
    let result = void 0;
    if (options.loadAdditionalAsset) {
      result = await options.loadAdditionalAsset(languageCode, segment, next);
    }
    result ?? (result = await next());
    if (Array.isArray(result)) {
      return await Promise.all(
        result.map(async (asset) => ({
          ...asset,
          data: await asset.data
        }))
      );
    }
    return result;
  };
  const getFonts = async () => {
    const fallback = async () => {
      const defaultFonts = [];
      const fallbackFont = await (renderOptions.defaultFont?.data ?? import_font.defaultFont.get());
      if (fallbackFont) {
        defaultFonts.push(
          new import_font.CustomFont("sans serif", fallbackFont, {
            weight: 400,
            style: "normal"
          })
        );
      } else {
        console.warn("(@cf-wasm/og) [ WARN ] No default font specified. Using 'Noto Sans' from Google Fonts as the fallback.");
        defaultFonts.push(
          new import_font.GoogleFont("Noto Sans", {
            name: "sans serif",
            weight: 400,
            style: "normal"
          })
        );
      }
      return Promise.all(
        [...defaultFonts, ...renderOptions.fonts].map(async (font) => ({
          ...font,
          data: await font.data
        }))
      );
    };
    promises.fonts = promises.fonts?.then(null, fallback) ?? fallback();
    return promises.fonts;
  };
  const asSvg = async () => {
    const fallback = async () => {
      const satoriFonts = await getFonts();
      const satoriOptions = {
        ...renderOptions.satoriOptions,
        width: renderOptions.width,
        height: renderOptions.height,
        debug: renderOptions.debug,
        fonts: satoriFonts,
        loadAdditionalAsset
      };
      const svg = await import_modules.modules.satori.satori(element, satoriOptions);
      return {
        image: svg,
        height: satoriOptions.height,
        width: satoriOptions.width,
        type: "image/svg+xml"
      };
    };
    promises.svg = promises.svg?.then(null, fallback) ?? fallback();
    return promises.svg;
  };
  const asPng = async () => {
    const fallback = async () => {
      const svg = await asSvg();
      const resvg = await import_modules.modules.resvg.Resvg.create(svg.image, {
        ...renderOptions.resvgOptions,
        fitTo: {
          mode: "width",
          value: renderOptions.width
        }
      });
      const renderedImage = resvg.render();
      const result = {
        pixels: renderedImage.pixels,
        image: renderedImage.asPng(),
        width: renderedImage.width,
        height: renderedImage.height,
        type: "image/png"
      };
      renderedImage.free();
      resvg.free();
      return result;
    };
    promises.png = promises.png?.then(null, fallback) ?? fallback();
    return promises.png;
  };
  return { asSvg, asPng };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  RENDER_DEFAULT_OPTIONS,
  render
});