@ogify/core 0.1.4 → 0.1.5

package/dist/index.js

@@ -3,10 +3,37 @@
 var satori = require('satori');
 var satoriHtml = require('satori-html');
 var resvgJs = require('@resvg/resvg-js');
+var lruCache = require('lru-cache');
+var fs = require('fs');
+var path = require('path');
+var crypto = require('crypto');
+var rtlCSSJS = require('rtl-css-js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
 var satori__default = /*#__PURE__*/_interopDefault(satori);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+var rtlCSSJS__default = /*#__PURE__*/_interopDefault(rtlCSSJS);
 
 // src/template.ts
 
@@ -175,6 +202,216 @@ var GoogleFontDetector = class {
     }
   }
 };
+var DEFAULT_TTL = 1e3 * 60 * 60 * 24 * 7;
+var DEFAULT_MAX = 100;
+var DEFAULT_CACHE_DIR = ".ogify-cache";
+var CacheManager = class {
+  cache;
+  config;
+  cacheDir = DEFAULT_CACHE_DIR;
+  /**
+   * Creates a new CacheManager instance.
+   *
+   * @param config - Cache configuration (memory or filesystem)
+   */
+  constructor(config) {
+    this.config = config;
+    if (config.type === "memory") {
+      this.cache = new lruCache.LRUCache({
+        max: config.max || DEFAULT_MAX,
+        ttl: config.ttl || DEFAULT_TTL
+      });
+    }
+    if (config.type === "filesystem") {
+      this.cacheDir = config.dir || DEFAULT_CACHE_DIR;
+      this.ensureCacheDirectory();
+      this.cleanExpiredFiles().catch((err) => {
+        console.warn("Failed to clean expired cache files:", err);
+      });
+    }
+  }
+  // eslint-disable-next-line
+  generateKey(object) {
+    const sorted = Object.keys(object).sort().map((key) => `${key}=${object[key]}`);
+    return crypto__namespace.createHash("md5").update(sorted.join("|")).digest("hex");
+  }
+  /**
+   * Retrieves a value from the cache.
+   *
+   * For filesystem cache, attempts to load from disk if not in memory.
+   *
+   * @param key - Cache key
+   * @returns Cached buffer or undefined if not found
+   */
+  async get(key) {
+    if (this.config.type === "memory") {
+      return this.cache?.get(key);
+    }
+    if (this.config.type === "filesystem") {
+      return this.loadFromDisk(key);
+    }
+    return void 0;
+  }
+  /**
+   * Stores a value in the cache.
+   *
+   * For filesystem cache, also persists to disk.
+   *
+   * @param key - Cache key
+   * @param value - Buffer to cache
+   */
+  async set(key, value) {
+    if (this.config.type === "memory") {
+      this.cache?.set(key, value);
+    }
+    if (this.config.type === "filesystem") {
+      await this.saveToDisk(key, value);
+    }
+  }
+  /**
+   * Checks if a key exists in the cache.
+   *
+   * @param key - Cache key
+   * @returns true if the key exists and is not expired
+   */
+  async has(key) {
+    if (this.config.type === "memory") {
+      return this.cache?.has(key) || false;
+    }
+    if (this.config.type === "filesystem") {
+      try {
+        await fs__namespace.promises.access(path__namespace.join(this.cacheDir, this.getFilename(key)));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * Clears all cached items.
+   *
+   * For filesystem cache, also removes all files from disk.
+   */
+  async clear() {
+    if (this.config.type === "memory") {
+      this.cache?.clear();
+    }
+    if (this.config.type === "filesystem") {
+      await this.clearFilesystem();
+    }
+  }
+  /**
+   * Ensures the cache directory exists.
+   * Creates it if it doesn't exist.
+   */
+  ensureCacheDirectory() {
+    if (!this.cacheDir) return;
+    if (!fs__namespace.existsSync(this.cacheDir)) {
+      fs__namespace.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+  /**
+   * Generates a safe filename from a cache key.
+   *
+   * Uses SHA-256 hash to avoid filesystem issues with special characters.
+   *
+   * @param key - Cache key
+   * @returns Safe filename
+   */
+  getFilename(key) {
+    const hash = crypto__namespace.createHash("sha256").update(key).digest("hex");
+    return `${hash}.cache`;
+  }
+  /**
+   * Loads a cached item from disk.
+   *
+   * @param key - Cache key
+   * @returns Cached buffer or undefined if not found or expired
+   */
+  async loadFromDisk(key) {
+    if (this.config.type !== "filesystem") return void 0;
+    const filename = this.getFilename(key);
+    const filepath = path__namespace.join(this.cacheDir, filename);
+    try {
+      try {
+        await fs__namespace.promises.access(filepath);
+      } catch {
+        return void 0;
+      }
+      const stats = await fs__namespace.promises.stat(filepath);
+      const age = Date.now() - stats.mtimeMs;
+      const ttl = this.config.ttl || DEFAULT_TTL;
+      if (age > ttl) {
+        await fs__namespace.promises.unlink(filepath).catch(() => {
+        });
+        return void 0;
+      }
+      const data = await fs__namespace.promises.readFile(filepath);
+      this.cache?.set(key, data);
+      return data;
+    } catch (error) {
+      return void 0;
+    }
+  }
+  /**
+   * Saves a cached item to disk.
+   *
+   * @param key - Cache key
+   * @param value - Buffer to save
+   */
+  async saveToDisk(key, value) {
+    if (this.config.type !== "filesystem") return;
+    const filename = this.getFilename(key);
+    const filepath = path__namespace.join(this.cacheDir, filename);
+    try {
+      await fs__namespace.promises.writeFile(filepath, value);
+    } catch (error) {
+    }
+  }
+  /**
+   * Loads all cached items from filesystem into memory on initialization.
+   */
+  async cleanExpiredFiles() {
+    if (this.config.type !== "filesystem") return;
+    try {
+      const files = await fs__namespace.promises.readdir(this.cacheDir);
+      for (const file of files) {
+        if (!file.endsWith(".cache")) continue;
+        const filepath = path__namespace.join(this.cacheDir, file);
+        try {
+          const stats = await fs__namespace.promises.stat(filepath);
+          const age = Date.now() - stats.mtimeMs;
+          const ttl = this.config.ttl || DEFAULT_TTL;
+          if (age > ttl) {
+            await fs__namespace.promises.unlink(filepath).catch(() => {
+            });
+          }
+        } catch {
+        }
+      }
+    } catch (error) {
+    }
+  }
+  /**
+   * Clears all files from the filesystem cache directory.
+   */
+  async clearFilesystem() {
+    if (this.config.type !== "filesystem") return;
+    const cacheDir = this.cacheDir;
+    try {
+      const files = await fs__namespace.promises.readdir(cacheDir);
+      const unlinkPromises = files.map(async (file) => {
+        if (!file.endsWith(".cache")) return;
+        const filepath = path__namespace.join(cacheDir, file);
+        await fs__namespace.promises.unlink(filepath).catch(() => {
+        });
+      });
+      await Promise.all(unlinkPromises);
+    } catch (error) {
+    }
+  }
+};
 
 // src/utils/emoji-loader.ts
 var ZERO_WIDTH_JOINER = String.fromCharCode(8205);
@@ -210,12 +447,15 @@ var apis = {
   fluent: (code) => `https://cdn.jsdelivr.net/gh/shuding/fluentui-emoji-unicode/assets/${code.toLowerCase()}_color.svg`,
   fluentFlat: (code) => `https://cdn.jsdelivr.net/gh/shuding/fluentui-emoji-unicode/assets/${code.toLowerCase()}_flat.svg`
 };
-var cache = {};
+var cache = new CacheManager({
+  type: "memory"
+});
 async function loadEmoji(type, text) {
   const code = getIconCode(text);
   const cacheKey = `${type}:${code}`;
-  if (cacheKey in cache) {
-    return cache[cacheKey];
+  const cached = await cache.get(cacheKey);
+  if (cached) {
+    return cached.toString();
   }
   if (!type || !apis[type]) {
     type = "noto";
@@ -224,19 +464,22 @@ async function loadEmoji(type, text) {
   const baseUrl = typeof api === "function" ? api(code) : api;
   const fullUrl = typeof api === "function" ? baseUrl : `${baseUrl}${code.toUpperCase()}.svg`;
   const emojiPromise = fetch(fullUrl).then((response) => response.text()).then((svgContent) => `data:image/svg+xml;base64,${btoa(svgContent)}`);
-  cache[cacheKey] = emojiPromise;
+  await cache.set(cacheKey, Buffer.from(await emojiPromise));
   return emojiPromise;
 }
 
-// src/utils/fetcher.ts
-var cache2 = {};
+// src/utils/font-fetcher.ts
+var cache2 = new CacheManager({
+  type: "memory"
+});
 var loadFontFromUrl = async (url) => {
-  if (url in cache2) {
-    return cache2[url];
+  const cachedFont = await cache2.get(url);
+  if (cachedFont) {
+    return cachedFont;
   }
-  const fontData = fetch(url).then((response) => response.arrayBuffer());
-  cache2[url] = fontData;
-  return fontData;
+  const fontData = await fetch(url).then((response) => response.arrayBuffer());
+  await cache2.set(url, Buffer.from(fontData));
+  return Buffer.from(fontData);
 };
 
 // src/utils/additional-asset-loader.ts
@@ -314,11 +557,12 @@ var DEFAULT_HEIGHT = 630;
 async function renderTemplate(template, params, options) {
   const width = options?.width || DEFAULT_WIDTH;
   const height = options?.height || DEFAULT_HEIGHT;
-  const satoriFonts = await loadFonts(template.fonts);
+  const fonts = options?.fonts?.length ? options.fonts : template.fonts;
+  const emojiProvider = options?.emojiProvider || template.emojiProvider || "noto";
+  const satoriFonts = await loadFonts(fonts);
   const htmlString = await template.renderer({
     params: typeof params === "function" ? await params() : params,
-    width,
-    height
+    ...options
   });
   const element = satoriHtml.html(htmlString);
   const svg = await satori__default.default(element, {
@@ -337,32 +581,25 @@ async function renderTemplate(template, params, options) {
         // Asset type ('emoji' or other)
         segment,
         // The character(s) to load
-        fonts: template.fonts,
+        fonts,
         // Available fonts for fallback detection
-        emojiProvider: template.emojiProvider || "noto"
+        emojiProvider
         // Emoji provider (default: noto)
       });
     }
   });
-  const resvg = new resvgJs.Resvg(svg, {
+  const pngData = await resvgJs.renderAsync(svg, {
     fitTo: {
       mode: "width",
       // Scale based on width, maintain aspect ratio
       value: width
     }
   });
-  const pngData = resvg.render();
   return Buffer.from(pngData.asPng());
 }
 
 // src/renderer.ts
 function validateTemplate(config) {
-  if (!config.id) {
-    throw new Error("Template must have an id");
-  }
-  if (!config.name) {
-    throw new Error("Template must have a name");
-  }
   if (typeof config.renderer !== "function") {
     throw new Error("Template must have a renderer function");
   }
@@ -372,9 +609,14 @@ function defineTemplate(config) {
   validateTemplate(config);
   return config;
 }
+var DEFAULT_CACHE = {
+  type: "memory"
+};
 var TemplateRenderer = class {
   /** Configuration including global settings and lifecycle hooks */
   config;
+  /** Cache manager for fonts and icons */
+  cacheManager;
   /**
    * Internal registry mapping template IDs to template definitions.
    *
@@ -383,7 +625,7 @@ var TemplateRenderer = class {
    * - Guaranteed insertion order
    * - Better memory efficiency than objects
    */
-  templates = /* @__PURE__ */ new Map();
+  templates = {};
   /**
    * Creates a new TemplateRenderer instance.
    *
@@ -391,6 +633,7 @@ var TemplateRenderer = class {
    */
   constructor(config) {
     this.config = config;
+    this.cacheManager = new CacheManager(config.cache || DEFAULT_CACHE);
     this.registerTemplates(config.templates);
   }
   /**
@@ -399,12 +642,13 @@ var TemplateRenderer = class {
    * Templates are indexed by their ID for fast lookup.
    * If a template with the same ID already exists, it will be overwritten.
    *
-   * @param templates - Array of template definitions to register
+   * @param templates - Map of template definitions to register
    */
   registerTemplates(templates) {
-    for (const template of templates) {
-      this.templates.set(template.id, template);
-    }
+    const keys = Object.keys(templates);
+    keys.forEach((key) => {
+      this.templates[key] = templates[key];
+    });
   }
   /**
    * Retrieves a template by its unique ID.
@@ -418,20 +662,7 @@ var TemplateRenderer = class {
    * @returns The template definition, or undefined if not found
    */
   getTemplate(id) {
-    return this.templates.get(id);
-  }
-  /**
-   * Gets all registered template IDs.
-   *
-   * Useful for:
-   * - Building template selection dropdowns
-   * - Listing available templates in documentation
-   * - Debugging template registration
-   *
-   * @returns Array of template IDs
-   */
-  getTemplateIds() {
-    return Array.from(this.templates.keys());
+    return this.templates[id];
   }
   /**
    * Renders a template to a PNG image buffer.
@@ -454,7 +685,7 @@ var TemplateRenderer = class {
    * - Throws if rendering fails (font loading, HTML generation, etc.)
    *
    * @param templateId - ID of the template to render
-   * @param params - Parameters to pass to the template
+   * @param params - Parameters (or function returning params) to pass to the template
    * @param options - Optional rendering options
    * @param options.width - Custom image width in pixels (default: 1200)
    * @param options.height - Custom image height in pixels (default: 630)
@@ -462,33 +693,69 @@ var TemplateRenderer = class {
    * @throws Error if template is not found or rendering fails
    */
   async renderToImage(templateId, params, options) {
-    const { defaultParams } = this.config;
+    const { sharedParams } = this.config;
     const template = this.getTemplate(templateId);
     if (!template) {
       throw new Error(`Template '${templateId}' not found`);
     }
     const mergedParams = {
-      ...typeof defaultParams === "function" ? await defaultParams() : defaultParams,
-      ...typeof params === "function" ? await params() : params
+      ...typeof sharedParams === "function" ? await sharedParams() : sharedParams || {},
+      ...typeof params === "function" ? await params() : params || {}
     };
+    const cacheKey = this.cacheManager.generateKey({
+      templateId,
+      ...mergedParams,
+      ...options
+    });
+    const cached = await this.cacheManager.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
     if (this.config.beforeRender) {
       await this.config.beforeRender(templateId, mergedParams);
     }
     const imageBuffer = await renderTemplate(template, mergedParams, options);
+    await this.cacheManager.set(cacheKey, imageBuffer);
     if (this.config.afterRender) {
       await this.config.afterRender(templateId, mergedParams, imageBuffer);
     }
     return imageBuffer;
   }
 };
-function createTemplateRenderer(config) {
+function createRenderer(config) {
   return new TemplateRenderer(config);
 }
-/*! Copyright Twitter Inc. and other contributors. Licensed under MIT */
+
+// src/utils/clsx.ts
+function clsx(...inputs) {
+  var i = 0, tmp, str = "", len = inputs.length;
+  for (; i < len; i++) {
+    if (tmp = inputs[i]) {
+      if (typeof tmp === "string") {
+        str += (str && " ") + tmp;
+      }
+    }
+  }
+  return str;
+}
+var objectToStyle = (style, options) => {
+  if (!style) {
+    return "";
+  }
+  const { isRTL = false } = options || {};
+  return Object.entries(isRTL ? rtlCSSJS__default.default(style) : style).filter(([_, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => {
+    if (value || value === 0) {
+      const cssKey = key.startsWith("--") ? key : key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      return `${cssKey}:${value}`;
+    }
+    return "";
+  }).filter(Boolean).join(";");
+};
 
 exports.TemplateRenderer = TemplateRenderer;
-exports.createTemplateRenderer = createTemplateRenderer;
+exports.clsx = clsx;
+exports.createRenderer = createRenderer;
 exports.defineTemplate = defineTemplate;
-exports.loadFontFromUrl = loadFontFromUrl;
+exports.objectToStyle = objectToStyle;
 exports.renderTemplate = renderTemplate;
 exports.validateTemplate = validateTemplate;