@ogify/core 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -1,6 +1,11 @@
 import satori from 'satori';
 import { html } from 'satori-html';
-import { Resvg } from '@resvg/resvg-js';
+import { renderAsync } from '@resvg/resvg-js';
+import { LRUCache } from 'lru-cache';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import rtlCSSJS from 'rtl-css-js';
 
 // src/template.ts
 
@@ -169,6 +174,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({
+        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.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.promises.access(path.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.existsSync(this.cacheDir)) {
+      fs.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.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.join(this.cacheDir, filename);
+    try {
+      try {
+        await fs.promises.access(filepath);
+      } catch {
+        return void 0;
+      }
+      const stats = await fs.promises.stat(filepath);
+      const age = Date.now() - stats.mtimeMs;
+      const ttl = this.config.ttl || DEFAULT_TTL;
+      if (age > ttl) {
+        await fs.promises.unlink(filepath).catch(() => {
+        });
+        return void 0;
+      }
+      const data = await fs.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.join(this.cacheDir, filename);
+    try {
+      await fs.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.promises.readdir(this.cacheDir);
+      for (const file of files) {
+        if (!file.endsWith(".cache")) continue;
+        const filepath = path.join(this.cacheDir, file);
+        try {
+          const stats = await fs.promises.stat(filepath);
+          const age = Date.now() - stats.mtimeMs;
+          const ttl = this.config.ttl || DEFAULT_TTL;
+          if (age > ttl) {
+            await fs.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.promises.readdir(cacheDir);
+      const unlinkPromises = files.map(async (file) => {
+        if (!file.endsWith(".cache")) return;
+        const filepath = path.join(cacheDir, file);
+        await fs.promises.unlink(filepath).catch(() => {
+        });
+      });
+      await Promise.all(unlinkPromises);
+    } catch (error) {
+    }
+  }
+};
 
 // src/utils/emoji-loader.ts
 var ZERO_WIDTH_JOINER = String.fromCharCode(8205);
@@ -204,12 +419,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";
@@ -218,19 +436,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
@@ -308,11 +529,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 = html(htmlString);
   const svg = await satori(element, {
@@ -331,32 +553,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 Resvg(svg, {
+  const pngData = await 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");
   }
@@ -366,9 +581,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.
    *
@@ -377,7 +597,7 @@ var TemplateRenderer = class {
    * - Guaranteed insertion order
    * - Better memory efficiency than objects
    */
-  templates = /* @__PURE__ */ new Map();
+  templates = {};
   /**
    * Creates a new TemplateRenderer instance.
    *
@@ -385,6 +605,7 @@ var TemplateRenderer = class {
    */
   constructor(config) {
     this.config = config;
+    this.cacheManager = new CacheManager(config.cache || DEFAULT_CACHE);
     this.registerTemplates(config.templates);
   }
   /**
@@ -393,12 +614,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.
@@ -412,20 +634,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.
@@ -448,7 +657,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)
@@ -456,28 +665,63 @@ 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 */
 
-export { TemplateRenderer, createTemplateRenderer, defineTemplate, loadFontFromUrl, renderTemplate, validateTemplate };
+// 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(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(";");
+};
+
+export { TemplateRenderer, clsx, createRenderer, defineTemplate, objectToStyle, renderTemplate, validateTemplate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogify/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Core types and utilities for OGify Open Graph image generator",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -15,6 +15,16 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage"
+  },
   "author": {
     "name": "Hung Pham - @revolabs-io",
     "email": "info@revolabs.io"
@@ -22,25 +32,17 @@
   "license": "MIT",
   "dependencies": {
     "@resvg/resvg-js": "^2.6.2",
+    "lru-cache": "^11.2.4",
+    "rtl-css-js": "^1.16.1",
     "satori": "^0.18.3",
     "satori-html": "^0.3.2"
   },
   "devDependencies": {
-    "@types/node": "^18",
+    "@types/node": "^20",
     "@vitest/ui": "^4.0.15",
     "happy-dom": "^20.0.11",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.15"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "lint": "tsc --noEmit",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 RevoLabs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.